MessageQueue удаляется более одного раза

Close освобождает все ресурсы объекта MessageQueue. См. документацию здесь. Ошибка, скорее всего, генерируется в CA, поскольку он видит, что путь выполнения Close также вызывает Dispose.

Из документации:

    public  void ReceiveMessage()
    {
        // Connect to the a on the local computer.
        MessageQueue myQueue = new MessageQueue(".\\myQueue");

        // Set the formatter to indicate body contains an Order.
        myQueue.Formatter = new XmlMessageFormatter(new Type[]
            {typeof(String)});

        try
        {
            // Receive and format the message. 
            Message myMessage1 = myQueue.Receive();
            Message myMessage2 = myQueue.Receive();
        }

        catch (MessageQueueException)
        {
            // Handle sources of any MessageQueueException.
        }

        // Catch other exceptions as necessary.

        finally
        {
            // Free resources.
            myQueue.Close();
        }

        return;
    }

Close, по-видимому, освободит ресурсы, но позволит компоненту повторно получить их, если они еще не собраны. Возможно, было бы более разумно открыть объект MessageQueue, использовать его, а затем закрыть в рамках одного и того же вызова, а не открывать его на определенный период времени и закрывать позже, поскольку кэширование соединения устраняет накладные расходы на открытие MessageQueue при повторных вызовах.

*ОБНОВЛЕНИЕ* Похоже, CA обрабатывает CA2202 по-разному для полей-членов по сравнению с передачей одноразового объекта методу, даже если этот метод является частным для класса. Несмотря на это, согласно документации, вам нужно вызывать только Close() или Dispose(), но не оба. Однако я рекомендую изменить ваш дизайн, чтобы вы создавали, использовали и затем закрывали объект MessageQueue в рамках ваших операций с сообщениями, как в примере из примера документации, показанного выше.

да. Это может удалить объект несколько раз:

Значение, которое вычисляет this._messageQueue, не изменяется после вызова MsmqHelper.DisposeQueue(this._messageQueue).

Только локальному параметру (с именем messageQueue) было присвоено значение null в методе DisposeQueue. Таким образом, «нулевая защита» не может правильно защитить последующие разы. (Это связано с тем, что C# по умолчанию использует Call-By-Value: см. ссылку на понять, что это означает в контексте «передачи значения ссылки на объект».)

Либо примите ref, либо назначьте this._messageQueue = null в вызывающем абоненте.

Если класс MessageQueue реализует IDisposable iterface, то нет смысла явно использовать метод Dispose и метод Close(), потому что во всех таких классах метод Close() обычно является не методом iterface, а классом метод. Как правило, в методе Dispose все правильные реализации должны вызывать метод Close() перед освобождением управляемых/неуправляемых ресурсов.

Опять же, внедряя внешний статический помощник, вы нарушаете шаблон Disposable. Это неправильный способ контролировать время жизни объекта; Вам не нужно возиться с шаблоном Disposable, вы можете просто использовать его

И ваш код может быть упрощен следующим образом:

    // 1. Use static class. By the agreement, all helper classes should be static to avoid 
    // IDisposable inheritance, in example
    public static class MsmqHelper//: IDisposable
    {
        //private MessageQueue _messageQueue;

        //public MessageQueueHelper(bool workflowCreated)
        //{
        //    this._messageQueue = MsmqHelper.InitializeQueue();
        //    this._messageQueue.Send(workflowCreated);
        //}

        public static SendMessage(object workflowCreated)
        {
            // 2. If static method in static class does not takes parameters, 
            // I might be better to to implicitly call the constructor?

            // using(MessageQueue msmsq = MsmqHelper.InitializeQueue())

            using(MessageQueue msmsq = new MessageQueue())
            {
                msmq.Send(workflowCreated);
                msmq.Close(); 

                // MsmqHelper.DisposeQueue(msmq);

                // 3. You should explicitly call Close object to immediately release     
                // unmanaged resources, while managed ones will be released 
                // at next GC rounds, as soon as possible
            }
        }
        //private MessageQueue _messageQueue;

        //public void Dispose()
        //{
        //    Dispose(true);
        //    GC.SuppressFinalize(this);
        //}

        //private void Dispose(bool disposing)
        //{
    //    if (disposing == false) { return; }
    //
    //    MsmqHelper.DisposeQueue(this._messageQueue);
    //}

    //public static void DisposeQueue(MessageQueue messageQueue)
    //{
    //    if (messageQueue != null)
    //    {
    //        messageQueue.Close();
    //        messageQueue.Dispose();
    //        messageQueue = null;
    //    }
    //}
}