如何在TFS服务器端实现签入规则：限制遗留WinForms项目文件扩容

Great question—this is such a common challenge when trying to rein in legacy codebloat without disrupting your team’s existing workflow. The good news is you can implement this rule on TFS, either via a custom client-side check-in policy or a more robust server-side event handler. Both options align with your goal: blocking file expansion while letting developers work on your 20k-line classes as long as they don’t add more lines.

Option 1: Custom Client-Side Check-in Policy (Easier to Roll Out) #

TFS lets you build custom check-in policies that run directly in Visual Studio during the check-in process. This alerts developers before they even attempt to submit code that violates your rule, which is gentler for teams unfamiliar with strict coding guardrails.

How to Build It: #

1. Create a Class Library Project targeting .NET Framework (match your TFS and Visual Studio version).
2. Add References to TFS client assemblies:
   • Microsoft.TeamFoundation.Client
   • Microsoft.TeamFoundation.VersionControl.Client
3. Implement the Policy by inheriting from PolicyBase:
   • Loop through each pending change in the Evaluate method.
   • For each .cs file (adjust extensions for your project), fetch the server’s latest version and count its lines.
   • Compare that to the local working copy’s line count.
   • If the local line count exceeds 2000 and is higher than the server’s version, add a policy failure to block the check-in.

Core Code Snippet: #

using System;
using System.Collections.Generic;
using System.IO;
using Microsoft.TeamFoundation.VersionControl.Client;

public class LineCountExpansionPolicy : PolicyBase
{
    private const int MaxAllowedLineThreshold = 2000;

    public override PolicyFailure[] Evaluate()
    {
        var failures = new List<PolicyFailure>();
        var pendingChanges = PendingCheckin.PendingChanges;

        foreach (var change in pendingChanges)
        {
            // Skip non-C# files (adjust extensions as needed for your project)
            if (!change.LocalItem.EndsWith(".cs", StringComparison.OrdinalIgnoreCase))
                continue;

            // Get line count of the server's latest version
            var serverItem = PendingCheckin.VersionControlServer.GetItem(change.ServerItem, VersionSpec.Latest);
            int serverLineCount;
            using (var stream = serverItem.DownloadFile())
            using (var reader = new StreamReader(stream))
            {
                serverLineCount = reader.ReadToEnd().Split('\n').Length;
            }

            // Get line count of the local working copy
            int localLineCount = File.ReadAllLines(change.LocalItem).Length;

            // Enforce the rule: no expansion for files over 2000 lines
            if (localLineCount > MaxAllowedLineThreshold && localLineCount > serverLineCount)
            {
                failures.Add(new PolicyFailure(
                    $"Blocked: {change.ServerItem} has grown to {localLineCount} lines (previous: {serverLineCount}). Files over {MaxAllowedLineThreshold} lines cannot be expanded.",
                    this));
            }
        }

        return failures.ToArray();
    }

    // Required metadata overrides for TFS policy listing
    public override string Description => "Prevents expanding files with more than 2000 lines to avoid further code bloat.";
    public override string TypeName => "Line Count Expansion Restriction";
    public override string TypeDescription => "Blocks check-ins where large files increase in line count.";
}

Deployment: #

• Compile the project to a DLL.
• Distribute the DLL to all developers’ Visual Studio installation directories: C:\Program Files (x86)\Microsoft Visual Studio\<Version>\Community\Common7\IDE\PrivateAssemblies (adjust path for your VS edition/version).
• In TFS, go to Team Project Settings > Source Control > Check-in Policies and add your new policy as a required rule.

Option 2: Server-Side Event Handler (More Secure, Harder to Bypass) #

Client-side policies can be disabled by developers, so for full enforcement, use a server-side event handler. This runs directly on the TFS server and blocks check-ins before they’re committed to the repository.

How to Build It: #

1. Create a Class Library Project targeting .NET Framework (match your TFS server version).
2. Add References to TFS server assemblies:
   • Microsoft.TeamFoundation.Framework.Server
   • Microsoft.TeamFoundation.VersionControl.Server
3. Implement ISubscriber to listen for the CheckinEvent:
   • In the ProcessEvent method, fetch the old and new versions of each changed file.
   • Compare line counts and block the check-in if your rule is violated.

Core Code Snippet: #

using System;
using System.IO;
using Microsoft.TeamFoundation.Framework.Server;
using Microsoft.TeamFoundation.VersionControl.Server;

public class CheckinLineCountEnforcer : ISubscriber
{
    private const int MaxAllowedLineThreshold = 2000;

    public string Name => "Line Count Expansion Enforcer";
    public SubscriberPriority Priority => SubscriberPriority.Normal;

    public Type[] SubscribedTypes() => new[] { typeof(CheckinEvent) };

    public EventNotificationStatus ProcessEvent(TeamFoundationRequestContext requestContext, NotificationType notificationType, object notificationEventArgs, out int statusCode, out string statusMessage, out ExceptionPropertyCollection properties)
    {
        statusCode = 0;
        statusMessage = string.Empty;
        properties = null;

        var checkinEvent = notificationEventArgs as CheckinEvent;
        if (checkinEvent == null)
            return EventNotificationStatus.ActionPermitted;

        var versionControlService = requestContext.GetService<IVersionControlService>();

        foreach (var change in checkinEvent.Changes)
        {
            if (!change.Item.ServerItem.EndsWith(".cs", StringComparison.OrdinalIgnoreCase))
                continue;

            // Get line count of the file before the check-in
            var oldVersion = new ChangesetVersionSpec(checkinEvent.ChangesetId - 1);
            var oldItem = versionControlService.GetItem(requestContext, change.Item.ServerItem, oldVersion, DeletedState.NonDeleted, ItemType.File, true);
            int oldLineCount;
            using (var stream = oldItem.DownloadFile())
            using (var reader = new StreamReader(stream))
            {
                oldLineCount = reader.ReadToEnd().Split('\n').Length;
            }

            // Get line count of the file being checked in
            var newVersion = new ChangesetVersionSpec(checkinEvent.ChangesetId);
            var newItem = versionControlService.GetItem(requestContext, change.Item.ServerItem, newVersion, DeletedState.NonDeleted, ItemType.File, true);
            int newLineCount;
            using (var stream = newItem.DownloadFile())
            using (var reader = new StreamReader(stream))
            {
                newLineCount = reader.ReadToEnd().Split('\n').Length;
            }

            if (newLineCount > MaxAllowedLineThreshold && newLineCount > oldLineCount)
            {
                statusCode = 403;
                statusMessage = $"Check-in blocked: {change.Item.ServerItem} has increased to {newLineCount} lines (previous: {oldLineCount}). Large files cannot be expanded.";
                return EventNotificationStatus.ActionDenied;
            }
        }

        return EventNotificationStatus.ActionPermitted;
    }
}

Deployment: #

• Compile the DLL.
• Copy it to the TFS Application Tier’s plugin directory: C:\Program Files\Microsoft Team Foundation Server\<Version>\Application Tier\Web Services\bin\Plugins.
• Restart the TFS server services to load the plugin.

Key Considerations for Your Legacy Project: #

• No Forced Refactoring: Both solutions let developers submit changes to your 20k-line classes as long as they don’t increase the line count (fixing bugs, removing dead code, etc. is fully allowed).
• Exceptions: Add a whitelist for specific files or users (e.g., senior developers splitting large classes) if you need to allow temporary expansions.
• Clear Messaging: The error messages explicitly explain why the check-in was blocked—this helps your team understand the rule without needing deep knowledge of modern coding standards.

内容的提问来源于stack exchange，提问作者Bogdan