MasayukiOzawa · December 18, 2025 23:58
diff --git a/EditorMonitor.cs b/EditorMonitor.cs
 using Microsoft.VisualStudio;
 using Microsoft.VisualStudio.Editor;
 using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Shell.Interop;
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.TextManager.Interop;
 using System;
 using System.IO;
 using System.Runtime.InteropServices;
 using System.Threading.Tasks;

 namespace VSIXProject1
 {
    internal sealed class EditorMonitor : IVsRunningDocTableEvents, IDisposable
    {
        private const string InsertedFlagKey = "IsolationLevelAutoInsert.Inserted";
        private const string InsertText = "SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;\r\n";

        private readonly AsyncPackage _package;
        private readonly IVsRunningDocumentTable _rdt;
        private readonly IVsEditorAdaptersFactoryService _editorAdaptersFactory;
        private readonly IVsTextManager _textManager;

        private uint _rdtCookie;

        public EditorMonitor(AsyncPackage package, IVsRunningDocumentTable rdt, IVsEditorAdaptersFactoryService editorAdaptersFactory, IVsTextManager textManager)
        {
            ThreadHelper.ThrowIfNotOnUIThread();

            _package = package ?? throw new ArgumentNullException(nameof(package));
            _rdt = rdt ?? throw new ArgumentNullException(nameof(rdt));
            _editorAdaptersFactory = editorAdaptersFactory ?? throw new ArgumentNullException(nameof(editorAdaptersFactory));
            _textManager = textManager ?? throw new ArgumentNullException(nameof(textManager));

            _rdt.AdviseRunningDocTableEvents(this, out _rdtCookie);
        }

        public void Dispose()
        {
            ThreadHelper.ThrowIfNotOnUIThread();

            if (_rdtCookie != 0)
            {
                _rdt.UnadviseRunningDocTableEvents(_rdtCookie);
                _rdtCookie = 0;
            }
        }

        private void TryInsertText(uint docCookie)
        {
            ThreadHelper.ThrowIfNotOnUIThread();

            _rdt.GetDocumentInfo(docCookie,
                out _, out _, out _,
                out string moniker, out _, out _, out IntPtr docData);

            if (docData == IntPtr.Zero)
            {
                return;
            }

            try
            {
                // Allow empty moniker (= Untitled/New Query), otherwise require .sql.
                if (!string.IsNullOrEmpty(moniker))
                {
                    var ext = Path.GetExtension(moniker);
                    if (!string.Equals(ext, ".sql", StringComparison.OrdinalIgnoreCase))
                    {
                        return;
                    }
                }

                var vsTextBuffer = Marshal.GetObjectForIUnknown(docData) as IVsTextBuffer;
                if (vsTextBuffer == null)
                {
                    return;
                }

                var wpfTextBuffer = _editorAdaptersFactory.GetDataBuffer(vsTextBuffer);
                if (wpfTextBuffer == null)
                {
                    return;
                }

                if (wpfTextBuffer.Properties.ContainsProperty(InsertedFlagKey))
                {
                    return;
                }

                if (wpfTextBuffer.CurrentSnapshot.Length != 0)
                {
                    return;
                }

                wpfTextBuffer.Properties.AddProperty(InsertedFlagKey, true);

                using (var edit = wpfTextBuffer.CreateEdit())
                {
                    edit.Insert(0, InsertText);
                    edit.Apply();
                }

                _ = _package.JoinableTaskFactory.RunAsync(async () =>
                {
                    await Task.Delay(100).ConfigureAwait(true);
                    await _package.JoinableTaskFactory.SwitchToMainThreadAsync();

                    _textManager.GetActiveView(1, null, out IVsTextView textView);
                    textView?.SetCaretPos(1, 0);
                });
            }
            finally
            {
                Marshal.Release(docData);
            }
        }

        public int OnAfterFirstDocumentLock(uint docCookie, uint dwRDTLockType, uint dwReadLocksRemaining, uint dwEditLocksRemaining)
        {
            try
            {
                ThreadHelper.ThrowIfNotOnUIThread();
                TryInsertText(docCookie);
            }
            catch
            {
                // Avoid crashing SSMS.
            }
            return VSConstants.S_OK;
        }

        public int OnBeforeDocumentWindowShow(uint docCookie, int fFirstShow, IVsWindowFrame pFrame)
        {
            try
            {
                ThreadHelper.ThrowIfNotOnUIThread();
                if (fFirstShow != 0)
                {
                    TryInsertText(docCookie);
                }
            }
            catch
            {
                // Avoid crashing SSMS.
            }
            return VSConstants.S_OK;
        }

        public int OnAfterAttributeChange(uint docCookie, uint grfAttribs) => VSConstants.S_OK;
        public int OnAfterDocumentWindowHide(uint docCookie, IVsWindowFrame pFrame) => VSConstants.S_OK;
        public int OnAfterSave(uint docCookie) => VSConstants.S_OK;
        public int OnBeforeLastDocumentUnlock(uint docCookie, uint dwRDTLockType, uint dwReadLocksRemaining, uint dwEditLocksRemaining) => VSConstants.S_OK;
    }
 }
diff --git a/FEATURE001_AutoInsertIsolationLevel.md b/FEATURE001_AutoInsertIsolationLevel.md
diff --git a/VSIXProject1Package.cs b/VSIXProject1Package.cs
 using Microsoft.VisualStudio.ComponentModelHost;
 using Microsoft.VisualStudio.Editor;
 using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Shell.Interop;
 using Microsoft.VisualStudio.TextManager.Interop;
 using System;
 using System.Runtime.InteropServices;
 using System.Threading;
 using Task = System.Threading.Tasks.Task;

 namespace VSIXProject1
 {
    /// <summary>
    /// This is the class that implements the package exposed by this assembly.
    /// </summary>
    /// <remarks>
    /// <para>
    /// The minimum requirement for a class to be considered a valid package for Visual Studio
    /// is to implement the IVsPackage interface and register itself with the shell.
    /// This package uses the helper classes defined inside the Managed Package Framework (MPF)
    /// to do it: it derives from the Package class that provides the implementation of the
    /// IVsPackage interface and uses the registration attributes defined in the framework to
    /// register itself and its components with the shell. These attributes tell the pkgdef creation
    /// utility what data to put into .pkgdef file.
    /// </para>
    /// <para>
    /// To get loaded into VS, the package must be referred by &lt;Asset Type="Microsoft.VisualStudio.VsPackage" ...&gt; in .vsixmanifest file.
    /// </para>
    /// </remarks>
    [PackageRegistration(UseManagedResourcesOnly = true, AllowsBackgroundLoading = true)]
    [ProvideAutoLoad(UIContextGuids.EmptySolution, PackageAutoLoadFlags.BackgroundLoad)]
    [ProvideAutoLoad(UIContextGuids.NoSolution, PackageAutoLoadFlags.BackgroundLoad)]
    [Guid(VSIXProject1Package.PackageGuidString)]
    public sealed class VSIXProject1Package : AsyncPackage
    {
        private EditorMonitor _editorMonitor;
        /// <summary>
        /// VSIXProject1Package GUID string.
        /// </summary>
        public const string PackageGuidString = "f2f34884-fbb6-4178-b7a0-c831dbdaec9c";

        #region Package Members

        /// <summary>
        /// Initialization of the package; this method is called right after the package is sited, so this is the place
        /// where you can put all the initialization code that rely on services provided by VisualStudio.
        /// </summary>
        /// <param name="cancellationToken">A cancellation token to monitor for initialization cancellation, which can occur when VS is shutting down.</param>
        /// <param name="progress">A provider for progress updates.</param>
        /// <returns>A task representing the async work of package initialization, or an already completed task if there is none. Do not return null from this method.</returns>
        protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress<ServiceProgressData> progress)
        {
            await base.InitializeAsync(cancellationToken, progress);
            await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);

            var rdt = await GetServiceAsync(typeof(SVsRunningDocumentTable)).ConfigureAwait(true) as IVsRunningDocumentTable;
            var textManager = await GetServiceAsync(typeof(SVsTextManager)).ConfigureAwait(true) as IVsTextManager;

            var componentModel = await GetServiceAsync(typeof(SComponentModel)).ConfigureAwait(true) as IComponentModel;
            var editorAdaptersFactory = componentModel?.GetService<IVsEditorAdaptersFactoryService>();

            if (rdt != null && textManager != null && editorAdaptersFactory != null)
            {
                _editorMonitor = new EditorMonitor(this, rdt, editorAdaptersFactory, textManager);
            }
        }

        protected override void Dispose(bool disposing)
        {
            ThreadHelper.ThrowIfNotOnUIThread();

            if (disposing)
            {
                _editorMonitor?.Dispose();
                _editorMonitor = null;
            }

            base.Dispose(disposing);
        }

        #endregion
    }
 }
	using Microsoft.VisualStudio;
	using Microsoft.VisualStudio.Editor;
	using Microsoft.VisualStudio.Shell;
	using Microsoft.VisualStudio.Shell.Interop;
	using Microsoft.VisualStudio.Text;
	using Microsoft.VisualStudio.TextManager.Interop;
	using System;
	using System.IO;
	using System.Runtime.InteropServices;
	using System.Threading.Tasks;

	namespace VSIXProject1
	{
	internal sealed class EditorMonitor : IVsRunningDocTableEvents, IDisposable
	{
	private const string InsertedFlagKey = "IsolationLevelAutoInsert.Inserted";
	private const string InsertText = "SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;\r\n";

	private readonly AsyncPackage _package;
	private readonly IVsRunningDocumentTable _rdt;
	private readonly IVsEditorAdaptersFactoryService _editorAdaptersFactory;
	private readonly IVsTextManager _textManager;

	private uint _rdtCookie;

	public EditorMonitor(AsyncPackage package, IVsRunningDocumentTable rdt, IVsEditorAdaptersFactoryService editorAdaptersFactory, IVsTextManager textManager)
	{
	ThreadHelper.ThrowIfNotOnUIThread();

	_package = package ?? throw new ArgumentNullException(nameof(package));
	_rdt = rdt ?? throw new ArgumentNullException(nameof(rdt));
	_editorAdaptersFactory = editorAdaptersFactory ?? throw new ArgumentNullException(nameof(editorAdaptersFactory));
	_textManager = textManager ?? throw new ArgumentNullException(nameof(textManager));

	_rdt.AdviseRunningDocTableEvents(this, out _rdtCookie);
	}

	public void Dispose()
	{
	ThreadHelper.ThrowIfNotOnUIThread();

	if (_rdtCookie != 0)
	{
	_rdt.UnadviseRunningDocTableEvents(_rdtCookie);
	_rdtCookie = 0;
	}
	}

	private void TryInsertText(uint docCookie)
	{
	ThreadHelper.ThrowIfNotOnUIThread();

	_rdt.GetDocumentInfo(docCookie,
	out _, out _, out _,
	out string moniker, out _, out _, out IntPtr docData);

	if (docData == IntPtr.Zero)
	{
	return;
	}

	try
	{
	// Allow empty moniker (= Untitled/New Query), otherwise require .sql.
	if (!string.IsNullOrEmpty(moniker))
	{
	var ext = Path.GetExtension(moniker);
	if (!string.Equals(ext, ".sql", StringComparison.OrdinalIgnoreCase))
	{
	return;
	}
	}

	var vsTextBuffer = Marshal.GetObjectForIUnknown(docData) as IVsTextBuffer;
	if (vsTextBuffer == null)
	{
	return;
	}

	var wpfTextBuffer = _editorAdaptersFactory.GetDataBuffer(vsTextBuffer);
	if (wpfTextBuffer == null)
	{
	return;
	}

	if (wpfTextBuffer.Properties.ContainsProperty(InsertedFlagKey))
	{
	return;
	}

	if (wpfTextBuffer.CurrentSnapshot.Length != 0)
	{
	return;
	}

	wpfTextBuffer.Properties.AddProperty(InsertedFlagKey, true);

	using (var edit = wpfTextBuffer.CreateEdit())
	{
	edit.Insert(0, InsertText);
	edit.Apply();
	}

	_ = _package.JoinableTaskFactory.RunAsync(async () =>
	{
	await Task.Delay(100).ConfigureAwait(true);
	await _package.JoinableTaskFactory.SwitchToMainThreadAsync();

	_textManager.GetActiveView(1, null, out IVsTextView textView);
	textView?.SetCaretPos(1, 0);
	});
	}
	finally
	{
	Marshal.Release(docData);
	}
	}

	public int OnAfterFirstDocumentLock(uint docCookie, uint dwRDTLockType, uint dwReadLocksRemaining, uint dwEditLocksRemaining)
	{
	try
	{
	ThreadHelper.ThrowIfNotOnUIThread();
	TryInsertText(docCookie);
	}
	catch
	{
	// Avoid crashing SSMS.
	}
	return VSConstants.S_OK;
	}

	public int OnBeforeDocumentWindowShow(uint docCookie, int fFirstShow, IVsWindowFrame pFrame)
	{
	try
	{
	ThreadHelper.ThrowIfNotOnUIThread();
	if (fFirstShow != 0)
	{
	TryInsertText(docCookie);
	}
	}
	catch
	{
	// Avoid crashing SSMS.
	}
	return VSConstants.S_OK;
	}

	public int OnAfterAttributeChange(uint docCookie, uint grfAttribs) => VSConstants.S_OK;
	public int OnAfterDocumentWindowHide(uint docCookie, IVsWindowFrame pFrame) => VSConstants.S_OK;
	public int OnAfterSave(uint docCookie) => VSConstants.S_OK;
	public int OnBeforeLastDocumentUnlock(uint docCookie, uint dwRDTLockType, uint dwReadLocksRemaining, uint dwEditLocksRemaining) => VSConstants.S_OK;
	}
	}
	using Microsoft.VisualStudio.ComponentModelHost;
	using Microsoft.VisualStudio.Editor;
	using Microsoft.VisualStudio.Shell;
	using Microsoft.VisualStudio.Shell.Interop;
	using Microsoft.VisualStudio.TextManager.Interop;
	using System;
	using System.Runtime.InteropServices;
	using System.Threading;
	using Task = System.Threading.Tasks.Task;

	namespace VSIXProject1
	{
	/// <summary>
	/// This is the class that implements the package exposed by this assembly.
	/// </summary>
	/// <remarks>
	/// <para>
	/// The minimum requirement for a class to be considered a valid package for Visual Studio
	/// is to implement the IVsPackage interface and register itself with the shell.
	/// This package uses the helper classes defined inside the Managed Package Framework (MPF)
	/// to do it: it derives from the Package class that provides the implementation of the
	/// IVsPackage interface and uses the registration attributes defined in the framework to
	/// register itself and its components with the shell. These attributes tell the pkgdef creation
	/// utility what data to put into .pkgdef file.
	/// </para>
	/// <para>
	/// To get loaded into VS, the package must be referred by <Asset Type="Microsoft.VisualStudio.VsPackage" ...> in .vsixmanifest file.
	/// </para>
	/// </remarks>
	[PackageRegistration(UseManagedResourcesOnly = true, AllowsBackgroundLoading = true)]
	[ProvideAutoLoad(UIContextGuids.EmptySolution, PackageAutoLoadFlags.BackgroundLoad)]
	[ProvideAutoLoad(UIContextGuids.NoSolution, PackageAutoLoadFlags.BackgroundLoad)]
	[Guid(VSIXProject1Package.PackageGuidString)]
	public sealed class VSIXProject1Package : AsyncPackage
	{
	private EditorMonitor _editorMonitor;
	/// <summary>
	/// VSIXProject1Package GUID string.
	/// </summary>
	public const string PackageGuidString = "f2f34884-fbb6-4178-b7a0-c831dbdaec9c";

	#region Package Members

	/// <summary>
	/// Initialization of the package; this method is called right after the package is sited, so this is the place
	/// where you can put all the initialization code that rely on services provided by VisualStudio.
	/// </summary>
	/// <param name="cancellationToken">A cancellation token to monitor for initialization cancellation, which can occur when VS is shutting down.</param>
	/// <param name="progress">A provider for progress updates.</param>
	/// <returns>A task representing the async work of package initialization, or an already completed task if there is none. Do not return null from this method.</returns>
	protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress<ServiceProgressData> progress)
	{
	await base.InitializeAsync(cancellationToken, progress);
	await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);

	var rdt = await GetServiceAsync(typeof(SVsRunningDocumentTable)).ConfigureAwait(true) as IVsRunningDocumentTable;
	var textManager = await GetServiceAsync(typeof(SVsTextManager)).ConfigureAwait(true) as IVsTextManager;

	var componentModel = await GetServiceAsync(typeof(SComponentModel)).ConfigureAwait(true) as IComponentModel;
	var editorAdaptersFactory = componentModel?.GetService<IVsEditorAdaptersFactoryService>();

	if (rdt != null && textManager != null && editorAdaptersFactory != null)
	{
	_editorMonitor = new EditorMonitor(this, rdt, editorAdaptersFactory, textManager);
	}
	}

	protected override void Dispose(bool disposing)
	{
	ThreadHelper.ThrowIfNotOnUIThread();

	if (disposing)
	{
	_editorMonitor?.Dispose();
	_editorMonitor = null;
	}

	base.Dispose(disposing);
	}

	#endregion
	}
	}