diff --git a/samples/AzureMapsControl.Sample/Components/Layout/NavMenu.razor b/samples/AzureMapsControl.Sample/Components/Layout/NavMenu.razor
index 4f33778..4a0e462 100644
--- a/samples/AzureMapsControl.Sample/Components/Layout/NavMenu.razor
+++ b/samples/AzureMapsControl.Sample/Components/Layout/NavMenu.razor
@@ -86,6 +86,9 @@
                         <li>
                             <NavLink class="dropdown-item" href="/Drawing/DrawingToolbarUpdate"> Toolbar update </NavLink>
                         </li>
+                        <li>
+                            <NavLink class="dropdown-item" href="/Drawing/DrawingManagerLoadData"> Load data to drawing manager </NavLink>
+                        </li>
                     </ul>
                 </li>
                 <NavLink class="nav-link" href="Indoor"> Indoor </NavLink>
diff --git a/samples/AzureMapsControl.Sample/Components/Pages/Drawing/DrawingManagerLoadData.razor b/samples/AzureMapsControl.Sample/Components/Pages/Drawing/DrawingManagerLoadData.razor
new file mode 100644
index 0000000..6a88084
--- /dev/null
+++ b/samples/AzureMapsControl.Sample/Components/Pages/Drawing/DrawingManagerLoadData.razor
@@ -0,0 +1,103 @@
+@page "/Drawing/DrawingManagerLoadData"
+@rendermode InteractiveServer
+
+@using AzureMapsControl.Components.Atlas
+@using AzureMapsControl.Components.Drawing
+@using AzureMapsControl.Components.Map
+
+
+<AzureMap Id="map"
+OnReady="MapReady"
+EventActivationFlags="MapEventActivationFlags.None().Enable(MapEventType.Ready)" />
+<div style="position: absolute; bottom: 10px; left: 10px; z-index: 1;">
+    <button @onclick="AddRandomShape">Add Random Shape</button>
+    <button @onclick="ClearShapes">Clear Shapes</button>
+</div>
+
+
+@code {
+    private DrawingManager? _drawingManager;
+    private Position _center = new Position(-122.33, 47.6);
+
+    public async Task MapReady(MapEventArgs eventArgs)
+    {
+        await eventArgs.Map.SetCameraOptionsAsync(options =>
+        {
+            options.Zoom = 10;
+            options.Center = _center;
+        });
+        await eventArgs.Map.AddDrawingToolbarAsync(new AzureMapsControl.Components.Drawing.DrawingToolbarOptions
+        {
+            Buttons = new[]
+            {
+                AzureMapsControl.Components.Drawing.DrawingButton.DrawCircle,
+                AzureMapsControl.Components.Drawing.DrawingButton.DrawLine,
+                AzureMapsControl.Components.Drawing.DrawingButton.EditGeometry
+            },
+            Position = AzureMapsControl.Components.Controls.ControlPosition.TopRight,
+            Style = AzureMapsControl.Components.Drawing.DrawingToolbarStyle.Dark
+        });
+
+        var lineString = new AzureMapsControl.Components.Atlas.LineString(new[]
+        {
+            new AzureMapsControl.Components.Atlas.Position(-122.27577, 47.55938),
+            new AzureMapsControl.Components.Atlas.Position(-122.29705, 47.60662),
+            new AzureMapsControl.Components.Atlas.Position(-122.22358, 47.6367)
+        });
+        var shape = new AzureMapsControl.Components.Atlas.Shape<AzureMapsControl.Components.Atlas.LineString>(lineString);
+        _drawingManager = eventArgs.Map.DrawingManager;
+        await _drawingManager.AddShapesAsync(new[] { shape });
+    }
+
+    private async Task AddRandomShape()
+    {
+        if (_drawingManager == null) return;
+
+        var random = new Random();
+        var shapeType = random.Next(3);
+        Shape shape;
+        var numberOfPoints = random.Next(3, 5);
+        var center = new Position(_center.Longitude + (random.NextDouble()-0.5) * 0.6, _center.Latitude + (random.NextDouble()-0.5) * 0.4);
+
+        switch (shapeType)
+        {
+            case 0: // Circle
+                var radius = random.NextDouble() * 2000;
+                shape = new Shape<Point>(new Point(center), new Dictionary<string, object>
+            {
+                { "subType", "Circle" },
+                { "radius", radius }
+            });
+                break;
+            case 1: // Polygon
+                var polygonPositions = new List<Position>();
+                for (var i = 0; i < numberOfPoints; i++)
+                {
+                    polygonPositions.Add(new Position(center.Longitude + (random.NextDouble()-0.5) * 0.1, center.Latitude + (random.NextDouble()-0.5) * 0.1));
+                }
+                polygonPositions.Add(polygonPositions[0]);
+                shape = new Shape<Polygon>(new Polygon(new[] { polygonPositions }));
+                break;
+            case 2: // Polyline
+                var polylinePositions = new List<Position>();
+                for (var i = 0; i < numberOfPoints; i++)
+                {
+                    polylinePositions.Add(new Position(center.Longitude + (random.NextDouble()-0.5) * 0.1, center.Latitude + (random.NextDouble()-0.5) * 0.1));
+                }
+                shape = new Shape<LineString>(new LineString(polylinePositions));
+                break;
+            default:
+                return;
+        }
+
+        await _drawingManager.AddShapesAsync(new[] { shape });
+    }
+
+    private async Task ClearShapes()
+    {
+        if (_drawingManager != null)
+        {
+            await _drawingManager.ClearAsync();
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/AzureMapsControl.Components/Drawing/DrawingManager.cs b/src/AzureMapsControl.Components/Drawing/DrawingManager.cs
new file mode 100644
index 0000000..1fe6879
--- /dev/null
+++ b/src/AzureMapsControl.Components/Drawing/DrawingManager.cs
@@ -0,0 +1,151 @@
+namespace AzureMapsControl.Components.Drawing
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Threading.Tasks;
+
+    using AzureMapsControl.Components.Atlas;
+    using AzureMapsControl.Components.Logger;
+    using AzureMapsControl.Components.Runtime;
+
+    using Microsoft.Extensions.Logging;
+
+
+    /// <summary>
+    /// DrawingManager for the DrawingToolbar
+    /// </summary>
+    public sealed class DrawingManager
+    {
+        internal IMapJsRuntime JSRuntime { get; set; }
+        internal ILogger Logger { get; set; }
+        public bool Disposed { get; private set; }
+
+        /// <summary>
+        /// List of shapes added to the data source
+        /// </summary>
+        private List<Shape> _sourceShapes;
+
+        /// <summary>
+        /// Add shapes to the drawing manager data source
+        /// </summary>
+        /// <param name="shapes">Shapes to add</param>
+        /// <returns></returns>
+        /// <exception cref="Exceptions.ComponentNotAddedToMapException">The control has not been added to the map</exception>
+        /// <exception cref="Exceptions.ComponentDisposedException">The control has already been disposed</exception>
+        public async ValueTask AddShapesAsync(IEnumerable<Shape> shapes)
+        {
+            if (shapes == null || !shapes.Any())
+            {
+                return;
+            }
+
+            EnsureJsRuntimeExists();
+            EnsureNotDisposed();
+
+            if (_sourceShapes == null)
+            {
+                _sourceShapes = new List<Shape>();
+            }
+
+            var lineStrings = shapes.OfType<Shape<LineString>>();
+            if (lineStrings.Any())
+            {
+                Logger?.LogAzureMapsControlDebug(AzureMapLogEvent.Source_AddAsync, $"{lineStrings.Count()} linestrings will be added");
+                await JSRuntime.InvokeVoidAsync(Constants.JsConstants.Methods.Source.AddShapes.ToDrawingNamespace(), lineStrings);
+            }
+
+            var multiLineStrings = shapes.OfType<Shape<MultiLineString>>();
+            if (multiLineStrings.Any())
+            {
+                Logger?.LogAzureMapsControlDebug(AzureMapLogEvent.Source_AddAsync, $"{multiLineStrings.Count()} multilinestrings will be added");
+                await JSRuntime.InvokeVoidAsync(Constants.JsConstants.Methods.Source.AddShapes.ToDrawingNamespace(), multiLineStrings);
+            }
+
+            var multiPoints = shapes.OfType<Shape<MultiPoint>>();
+            if (multiPoints.Any())
+            {
+                Logger?.LogAzureMapsControlDebug(AzureMapLogEvent.Source_AddAsync, $"{multiPoints.Count()} multipoints will be added");
+                await JSRuntime.InvokeVoidAsync(Constants.JsConstants.Methods.Source.AddShapes.ToDrawingNamespace(), multiPoints);
+            }
+
+            var multiPolygons = shapes.OfType<Shape<MultiPolygon>>();
+            if (multiPolygons.Any())
+            {
+                Logger?.LogAzureMapsControlDebug(AzureMapLogEvent.Source_AddAsync, $"{multiPolygons.Count()} multipolygons will be added");
+                await JSRuntime.InvokeVoidAsync(Constants.JsConstants.Methods.Source.AddShapes.ToDrawingNamespace(), multiPolygons);
+            }
+
+            var points = shapes.OfType<Shape<Point>>();
+            if (points.Any())
+            {
+                Logger?.LogAzureMapsControlDebug(AzureMapLogEvent.Source_AddAsync, $"{points.Count()} points will be added");
+                await JSRuntime.InvokeVoidAsync(Constants.JsConstants.Methods.Source.AddShapes.ToDrawingNamespace(), points);
+            }
+
+            var polygons = shapes.OfType<Shape<Polygon>>();
+            if (polygons.Any())
+            {
+                Logger?.LogAzureMapsControlDebug(AzureMapLogEvent.Source_AddAsync, $"{polygons.Count()} polygons will be added");
+                await JSRuntime.InvokeVoidAsync(Constants.JsConstants.Methods.Source.AddShapes.ToDrawingNamespace(), polygons);
+            }
+
+            var routePoints = shapes.OfType<Shape<RoutePoint>>();
+            if (routePoints.Any())
+            {
+                Logger?.LogAzureMapsControlDebug(AzureMapLogEvent.Source_AddAsync, $"{routePoints.Count()} route points will be added");
+                await JSRuntime.InvokeVoidAsync(Constants.JsConstants.Methods.Source.AddShapes.ToDrawingNamespace(), routePoints);
+            }
+
+            _sourceShapes.AddRange(shapes);
+        }
+
+        /// <summary>
+        /// Clear the drawing manager source
+        /// </summary>
+        /// <returns></returns>
+        /// <exception cref="Exceptions.ComponentNotAddedToMapException">The control has not been added to the map</exception>
+        /// <exception cref="Exceptions.ComponentDisposedException">The control has already been disposed</exception>
+        public async ValueTask ClearAsync()
+        {
+            Logger?.LogAzureMapsControlInfo(AzureMapLogEvent.Source_ClearAsync, "Clearing drawing manager source");
+
+            EnsureJsRuntimeExists();
+            EnsureNotDisposed();
+
+            _sourceShapes = null;
+            await JSRuntime.InvokeVoidAsync(Constants.JsConstants.Methods.Source.Clear.ToDrawingNamespace());
+        }
+
+        /// <summary>
+        /// Mark the control as disposed
+        /// </summary>
+        /// <returns></returns>
+        /// <exception cref="Exceptions.ComponentNotAddedToMapException">The control has not been added to the map</exception>
+        /// <exception cref="Exceptions.ComponentDisposedException">The control has already been disposed</exception>
+        internal void Dispose()
+        {
+            Logger?.LogAzureMapsControlInfo(AzureMapLogEvent.Source_DisposeAsync, "DrawingManager - Dispose");
+
+            EnsureJsRuntimeExists();
+            EnsureNotDisposed();
+
+            Disposed = true;
+        }
+
+        private void EnsureJsRuntimeExists()
+        {
+            if (JSRuntime is null)
+            {
+                throw new Exceptions.ComponentNotAddedToMapException();
+            }
+        }
+
+        private void EnsureNotDisposed()
+        {
+            if (Disposed)
+            {
+                throw new Exceptions.ComponentDisposedException();
+            }
+        }
+    }
+}
diff --git a/src/AzureMapsControl.Components/Map/Map.cs b/src/AzureMapsControl.Components/Map/Map.cs
index 0bfee93..3b28206 100644
--- a/src/AzureMapsControl.Components/Map/Map.cs
+++ b/src/AzureMapsControl.Components/Map/Map.cs
@@ -67,6 +67,8 @@ public sealed class Map
 
         public DrawingToolbarOptions DrawingToolbarOptions { get; internal set; }
 
+        public DrawingManager DrawingManager { get; internal set; }
+
         public IEnumerable<Control> Controls => _controls;
 
         public IEnumerable<Layer> Layers => _layers;
@@ -352,6 +354,10 @@ await _jsRuntime.InvokeVoidAsync(Constants.JsConstants.Methods.Drawing.AddDrawin
                     Events = drawingToolbarOptions.Events?.EnabledEvents
                 },
                 DotNetObjectReference.Create(_drawingToolbarEventInvokeHelper));
+                DrawingManager = new DrawingManager() {
+                    JSRuntime = _jsRuntime,
+                    Logger = _logger
+                };
             }
         }
 
@@ -394,6 +400,8 @@ public async ValueTask RemoveDrawingToolbarAsync()
             {
                 await _jsRuntime.InvokeVoidAsync(Constants.JsConstants.Methods.Drawing.RemoveDrawingToolbar.ToDrawingNamespace());
                 DrawingToolbarOptions = null;
+                DrawingManager?.Dispose();
+                DrawingManager = null;
             }
         }
 
diff --git a/src/AzureMapsControl.Components/typescript/drawing/drawing.ts b/src/AzureMapsControl.Components/typescript/drawing/drawing.ts
index 4959cac..69120bf 100644
--- a/src/AzureMapsControl.Components/typescript/drawing/drawing.ts
+++ b/src/AzureMapsControl.Components/typescript/drawing/drawing.ts
@@ -3,6 +3,8 @@ import * as azmaps from 'azure-maps-control';
 import { EventHelper } from '../events/event-helper';
 import { Core } from '../core/core';
 import { DrawingEventArgs } from './drawing-event-args';
+import { Shape } from '../geometries/geometry';
+import { GeometryBuilder } from '../geometries/geometry-builder';
 
 export class Drawing {
 
@@ -96,4 +98,13 @@ export class Drawing {
         });
     }
 
+    public static addShapes(shapes: Shape[]): void {
+        const mapsShapes = shapes.map(shape => GeometryBuilder.buildShape(shape));
+        this._drawingManager.getSource().add(mapsShapes);
+    }
+
+    public static clear(): void {
+        this._drawingManager.getSource().clear();
+    }
+
 }
\ No newline at end of file
diff --git a/tests/AzureMapsControl.Components.Tests/Drawing/DrawingManager.cs b/tests/AzureMapsControl.Components.Tests/Drawing/DrawingManager.cs
new file mode 100644
index 0000000..f6eab30
--- /dev/null
+++ b/tests/AzureMapsControl.Components.Tests/Drawing/DrawingManager.cs
@@ -0,0 +1,313 @@
+namespace AzureMapsControl.Components.Tests.Drawing
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Reflection;
+    using System.Threading.Tasks;
+
+    using AzureMapsControl.Components.Atlas;
+    using AzureMapsControl.Components.Drawing;
+    using AzureMapsControl.Components.Exceptions;
+    using AzureMapsControl.Components.Runtime;
+
+    using Microsoft.Extensions.Logging;
+
+    using Moq;
+
+    using Xunit;
+
+    public class DrawingManagerTests
+    {
+        private readonly Mock<IMapJsRuntime> _jsRuntimeMock = new();
+        private readonly Mock<ILogger> _loggerMock = new();
+
+        [Fact]
+        public void Should_HaveDefaultProperties()
+        {
+            var drawingManager = new DrawingManager();
+            
+            Assert.False(drawingManager.Disposed);
+            Assert.Null(drawingManager.JSRuntime);
+            Assert.Null(drawingManager.Logger);
+        }
+
+        [Fact]
+        public void Should_SetJSRuntimeAndLogger()
+        {
+            var drawingManager = CreateInitializedDrawingManager();
+
+            Assert.Equal(_jsRuntimeMock.Object, drawingManager.JSRuntime);
+            Assert.Equal(_loggerMock.Object, drawingManager.Logger);
+        }
+
+        [Fact]
+        public async Task Should_AddShapes_AllSupportedGeometryTypes_Async()
+        {
+            var drawingManager = CreateInitializedDrawingManager();
+
+            var shapes = new List<Shape> 
+            {
+                new Shape<Point>(new Point()),
+                new Shape<LineString>(new LineString()),
+                new Shape<MultiLineString>(new MultiLineString()),
+                new Shape<MultiPoint>(new MultiPoint()),
+                new Shape<MultiPolygon>(new MultiPolygon()),
+                new Shape<Polygon>(new Polygon()),
+                new Shape<RoutePoint>(new RoutePoint()),
+            };
+
+            await drawingManager.AddShapesAsync(shapes);
+
+            _jsRuntimeMock.Verify(runtime => runtime.InvokeVoidAsync(Constants.JsConstants.Methods.Source.AddShapes.ToDrawingNamespace(), It.Is<IEnumerable<Shape<Point>>>(s => s.Count() == 1)), Times.Once);
+            _jsRuntimeMock.Verify(runtime => runtime.InvokeVoidAsync(Constants.JsConstants.Methods.Source.AddShapes.ToDrawingNamespace(), It.Is<IEnumerable<Shape<LineString>>>(s => s.Count() == 1)), Times.Once);
+            _jsRuntimeMock.Verify(runtime => runtime.InvokeVoidAsync(Constants.JsConstants.Methods.Source.AddShapes.ToDrawingNamespace(), It.Is<IEnumerable<Shape<MultiLineString>>>(s => s.Count() == 1)), Times.Once);
+            _jsRuntimeMock.Verify(runtime => runtime.InvokeVoidAsync(Constants.JsConstants.Methods.Source.AddShapes.ToDrawingNamespace(), It.Is<IEnumerable<Shape<MultiPoint>>>(s => s.Count() == 1)), Times.Once);
+            _jsRuntimeMock.Verify(runtime => runtime.InvokeVoidAsync(Constants.JsConstants.Methods.Source.AddShapes.ToDrawingNamespace(), It.Is<IEnumerable<Shape<MultiPolygon>>>(s => s.Count() == 1)), Times.Once);
+            _jsRuntimeMock.Verify(runtime => runtime.InvokeVoidAsync(Constants.JsConstants.Methods.Source.AddShapes.ToDrawingNamespace(), It.Is<IEnumerable<Shape<Polygon>>>(s => s.Count() == 1)), Times.Once);
+            _jsRuntimeMock.Verify(runtime => runtime.InvokeVoidAsync(Constants.JsConstants.Methods.Source.AddShapes.ToDrawingNamespace(), It.Is<IEnumerable<Shape<RoutePoint>>>(s => s.Count() == 1)), Times.Once);
+            _jsRuntimeMock.Verify(runtime => runtime.InvokeVoidAsync(Constants.JsConstants.Methods.Source.AddShapes.ToDrawingNamespace(), It.IsAny<object[]>()), Times.Exactly(7));
+
+            _jsRuntimeMock.VerifyNoOtherCalls();
+        }
+
+        [Fact]
+        public async Task Should_AddMultipleShapesOfSameType_Async()
+        {
+            var drawingManager = CreateInitializedDrawingManager();
+
+            var shapes = new List<Shape> 
+            {
+                new Shape<Point>(new Point()),
+                new Shape<Point>(new Point()),
+                new Shape<Point>(new Point())
+            };
+
+            await drawingManager.AddShapesAsync(shapes);
+
+            _jsRuntimeMock.Verify(runtime => runtime.InvokeVoidAsync(Constants.JsConstants.Methods.Source.AddShapes.ToDrawingNamespace(), It.Is<IEnumerable<Shape<Point>>>(s => s.Count() == 3)), Times.Once);
+            _jsRuntimeMock.VerifyNoOtherCalls();
+        }
+
+        [Fact]
+        public async Task Should_HandleMixedGeometryTypes_InSingleCall_Async()
+        {
+            var drawingManager = CreateInitializedDrawingManager();
+
+            var shapes = new List<Shape>
+            {
+                new Shape<Point>(new Point()),
+                new Shape<Point>(new Point()),
+                new Shape<LineString>(new LineString()),
+                new Shape<Polygon>(new Polygon()),
+                new Shape<Polygon>(new Polygon()),
+                new Shape<Polygon>(new Polygon())
+            };
+
+            await drawingManager.AddShapesAsync(shapes);
+
+            _jsRuntimeMock.Verify(runtime => runtime.InvokeVoidAsync(Constants.JsConstants.Methods.Source.AddShapes.ToDrawingNamespace(), It.Is<IEnumerable<Shape<Point>>>(s => s.Count() == 2)), Times.Once);
+            _jsRuntimeMock.Verify(runtime => runtime.InvokeVoidAsync(Constants.JsConstants.Methods.Source.AddShapes.ToDrawingNamespace(), It.Is<IEnumerable<Shape<LineString>>>(s => s.Count() == 1)), Times.Once);
+            _jsRuntimeMock.Verify(runtime => runtime.InvokeVoidAsync(Constants.JsConstants.Methods.Source.AddShapes.ToDrawingNamespace(), It.Is<IEnumerable<Shape<Polygon>>>(s => s.Count() == 3)), Times.Once);
+            _jsRuntimeMock.Verify(runtime => runtime.InvokeVoidAsync(Constants.JsConstants.Methods.Source.AddShapes.ToDrawingNamespace(), It.IsAny<object[]>()), Times.Exactly(3));
+
+            _jsRuntimeMock.VerifyNoOtherCalls();
+        }
+
+        [Fact]
+        public async Task Should_HandleLargeNumberOfShapes_Efficiently_Async()
+        {
+            var drawingManager = CreateInitializedDrawingManager();
+
+            // Create a large collection of shapes
+            var shapes = new List<Shape>();
+            for (int i = 0; i < 1000; i++)
+            {
+                shapes.Add(new Shape<Point>(new Point()));
+            }
+
+            await drawingManager.AddShapesAsync(shapes);
+
+            // Should still only make one call per geometry type
+            _jsRuntimeMock.Verify(runtime => runtime.InvokeVoidAsync(Constants.JsConstants.Methods.Source.AddShapes.ToDrawingNamespace(), It.Is<IEnumerable<Shape<Point>>>(s => s.Count() == 1000)), Times.Once);
+            _jsRuntimeMock.VerifyNoOtherCalls();
+        }
+
+        [Fact]
+        public async Task Should_NotAddShapes_WhenNull_Async()
+        {
+            var drawingManager = CreateInitializedDrawingManager();
+
+            await drawingManager.AddShapesAsync(null);
+
+            _jsRuntimeMock.VerifyNoOtherCalls();
+        }
+
+        [Fact]
+        public async Task Should_NotAddShapes_WhenEmpty_Async()
+        {
+            var drawingManager = CreateInitializedDrawingManager();
+
+            await drawingManager.AddShapesAsync(new List<Shape>());
+
+            _jsRuntimeMock.VerifyNoOtherCalls();
+        }
+
+        [Fact]
+        public async Task Should_ClearShapes_Async()
+        {
+            var drawingManager = CreateInitializedDrawingManager();
+
+            await drawingManager.ClearAsync();
+
+            _jsRuntimeMock.Verify(runtime => runtime.InvokeVoidAsync(Constants.JsConstants.Methods.Source.Clear.ToDrawingNamespace()), Times.Once);
+            _jsRuntimeMock.VerifyNoOtherCalls();
+        }
+
+        [Fact]
+        public async Task Should_AccumulateShapes_InInternalState_Async()
+        {
+            var drawingManager = CreateInitializedDrawingManager();
+
+            var firstBatch = new List<Shape> { new Shape<Point>(new Point()) };
+            var secondBatch = new List<Shape> { new Shape<LineString>(new LineString()) };
+            var thirdBatch = new List<Shape> { new Shape<Point>(new Point()) };
+
+            await drawingManager.AddShapesAsync(firstBatch);
+            await drawingManager.AddShapesAsync(secondBatch);
+            await drawingManager.AddShapesAsync(thirdBatch);
+
+            // Verify internal state accumulates all shapes
+            var sourceShapes = GetInternalSourceShapes(drawingManager);
+            Assert.Equal(3, sourceShapes.Count);
+            Assert.Contains(firstBatch[0], sourceShapes);
+            Assert.Contains(secondBatch[0], sourceShapes);
+            Assert.Contains(thirdBatch[0], sourceShapes);
+
+            // Verify correct number of JS calls
+            _jsRuntimeMock.Verify(runtime => runtime.InvokeVoidAsync(
+                Constants.JsConstants.Methods.Source.AddShapes.ToDrawingNamespace(),
+                It.IsAny<object[]>()), Times.Exactly(3)); // 1 Point call + 1 LineString call + 1 more Point call
+        }
+
+        [Fact]
+        public async Task Should_ClearInternalState_WhenCleared_Async()
+        {
+            var drawingManager = CreateInitializedDrawingManager();
+            var shapes = new List<Shape> { new Shape<Point>(new Point()) };
+
+            // Add shapes to initialize and populate internal state
+            await drawingManager.AddShapesAsync(shapes);
+            var sourceShapes = GetInternalSourceShapes(drawingManager);
+            Assert.NotNull(sourceShapes);
+            Assert.Single(sourceShapes);
+
+            // Clear should reset internal state
+            await drawingManager.ClearAsync();
+            sourceShapes = GetInternalSourceShapes(drawingManager);
+            Assert.Null(sourceShapes);
+
+            // Adding again should reinitialize state
+            await drawingManager.AddShapesAsync(shapes);
+            sourceShapes = GetInternalSourceShapes(drawingManager);
+            Assert.NotNull(sourceShapes);
+            Assert.Single(sourceShapes);
+
+            _jsRuntimeMock.Verify(runtime => runtime.InvokeVoidAsync(Constants.JsConstants.Methods.Source.AddShapes.ToDrawingNamespace(), It.IsAny<object[]>()), Times.Exactly(2));
+            _jsRuntimeMock.Verify(runtime => runtime.InvokeVoidAsync(Constants.JsConstants.Methods.Source.Clear.ToDrawingNamespace()), Times.Once);
+            _jsRuntimeMock.VerifyNoOtherCalls();
+        }
+
+        [Fact]
+        public void Should_Dispose_Successfully()
+        {
+            var drawingManager = CreateInitializedDrawingManager();
+
+            Assert.False(drawingManager.Disposed);
+
+            drawingManager.Dispose();
+
+            Assert.True(drawingManager.Disposed);
+        }
+
+        [Fact]
+        public async Task Should_ThrowComponentNotAddedToMapException_WhenJSRuntimeIsNull_Clear_Async()
+        {
+            var drawingManager = new DrawingManager();
+
+            await Assert.ThrowsAsync<ComponentNotAddedToMapException>(async () => await drawingManager.ClearAsync());
+
+            _jsRuntimeMock.VerifyNoOtherCalls();
+        }
+
+        [Fact]
+        public async Task Should_ThrowComponentNotAddedToMapException_WhenJSRuntimeIsNull_AddShapes_Async()
+        {
+            var drawingManager = new DrawingManager();
+            var shapes = new List<Shape> { new Shape<Point>(new Point()) };
+
+            await Assert.ThrowsAsync<ComponentNotAddedToMapException>(async () => await drawingManager.AddShapesAsync(shapes));
+
+            _jsRuntimeMock.VerifyNoOtherCalls();
+        }
+
+        [Fact]
+        public void Should_ThrowComponentNotAddedToMapException_WhenJSRuntimeIsNull_Dispose()
+        {
+            var drawingManager = new DrawingManager();
+
+            Assert.Throws<ComponentNotAddedToMapException>(() => drawingManager.Dispose());
+        }
+
+        [Fact]
+        public async Task Should_ThrowComponentDisposedException_WhenDisposed_Clear_Async()
+        {
+            var drawingManager = CreateInitializedDrawingManager();
+
+            drawingManager.Dispose();
+
+            await Assert.ThrowsAsync<ComponentDisposedException>(async () => await drawingManager.ClearAsync());
+
+            _jsRuntimeMock.VerifyNoOtherCalls();
+        }
+
+        [Fact]
+        public async Task Should_ThrowComponentDisposedException_WhenDisposed_AddShapes_Async()
+        {
+            var drawingManager = CreateInitializedDrawingManager();
+
+            drawingManager.Dispose();
+            var shapes = new List<Shape> { new Shape<Point>(new Point()) };
+
+            await Assert.ThrowsAsync<ComponentDisposedException>(async () => await drawingManager.AddShapesAsync(shapes));
+
+            _jsRuntimeMock.VerifyNoOtherCalls();
+        }
+
+        [Fact]
+        public void Should_ThrowComponentDisposedException_WhenAlreadyDisposed_Dispose()
+        {
+            var drawingManager = CreateInitializedDrawingManager();
+            drawingManager.Dispose();
+
+            Assert.Throws<ComponentDisposedException>(() => drawingManager.Dispose());
+        }
+
+        private DrawingManager CreateInitializedDrawingManager()
+        {
+            return new DrawingManager() {
+                JSRuntime = _jsRuntimeMock.Object,
+                Logger = _loggerMock.Object
+            };
+        }
+
+        /// <summary>
+        /// Uses reflection to access the private _sourceShapes field for testing internal state
+        /// </summary>
+        private List<Shape> GetInternalSourceShapes(DrawingManager drawingManager)
+        {
+            var field = typeof(DrawingManager).GetField("_sourceShapes",
+                BindingFlags.NonPublic | BindingFlags.Instance);
+            return field?.GetValue(drawingManager) as List<Shape>;
+        }
+    }
+}