Classe AssemblyInitializeAttribute

Articolo
09/12/2008

Aggiornamento: novembre 2007

Consente di identificare un metodo che contiene il codice da utilizzare prima dell'esecuzione di tutti i test dell'assieme e di allocare le risorse ottenute dall'assembly. La classe non può essere ereditata.

Spazio dei nomi: Microsoft.VisualStudio.TestTools.UnitTesting
Assembly: Microsoft.VisualStudio.QualityTools.UnitTestFramework (in Microsoft.VisualStudio.QualityTools.UnitTestFramework.dll)

Sintassi

<AttributeUsageAttribute(AttributeTargets.Method, AllowMultiple := False)> _
Public NotInheritable Class AssemblyInitializeAttribute _
    Inherits Attribute

Dim instance As AssemblyInitializeAttribute

[AttributeUsageAttribute(AttributeTargets.Method, AllowMultiple = false)]
public sealed class AssemblyInitializeAttribute : Attribute

[AttributeUsageAttribute(AttributeTargets::Method, AllowMultiple = false)]
public ref class AssemblyInitializeAttribute sealed : public Attribute

public final class AssemblyInitializeAttribute extends Attribute

Note

Il metodo contrassegnato da questo attributo verrà eseguito prima dei metodi contrassegnati con gli attributi ClassInitializeAttribute, TestInitializeAttribute e TestMethodAttribute. In un assembly è possibile decorare un solo metodo con questo attributo.

Nota importante:
Questo attributo non dovrebbe essere utilizzato sui test di unità di ASP.NET, vale a dire, nessun test con l'attributo [HostType("ASP.NET")]. A causa della natura priva di stato di IIS e ASP.NET, è possibile chiamare più di una volta per test eseguito un metodo decorato con questo attributo.

È possibile specificare questo attributo su un metodo. È possibile applicare solo un'istanza di questo attributo a un metodo.

Nota:
Il motore di test esegue un metodo contrassegnato con l'attributo AssemblyInitialize solo se quel metodo è un membro di una classe contrassegnata con l'attributo TestClass.

Per ulteriori informazioni sulla modalità di utilizzo degli attributi, vedere Estensione di metadati mediante attributi.

Esempi

Negli esempi elencati di seguito vengono illustrati gli attributi di inizializzazione e di eliminazione utilizzati per indicare quali metodi debbano essere eseguiti dal modulo del test in momenti diversi del test.

I primi esempi di codice contengono una classe e un metodo di cui eseguire il test. Per eseguire questo esempio, creare un progetto della libreria di classi e sostituire il codice con l'esempio seguente.

using System;

namespace SampleClassLib
{
    public class DivideClass
    {
        public static int DivideMethod(int denominator)
        {
            return (2 / denominator);
        }
    }
}

Imports System

Namespace SampleClassLib
    Public Class DivideClass
        Shared Function DivideMethod(ByVal denominator As Integer) As Integer
            Return 2 \ denominator
        End Function
    End Class
End Namespace

Nell'esempio illustrato di seguito è contenuto il codice per verificare DivideMethod() trovato negli esempi di codice precedenti. Creare un progetto di test e inserire il codice seguente nel documento di una classe di test. Aggiungere i riferimenti appropriati al progetto. Questo codice contiene attributi che controllano l'inizializzazione e l'ordine di esecuzione dell'eliminazione per il metodo, la classe e l'assembly.

In particolare si noti l'attributo AssemblyInitialize nel metodo AssemblyInit()method.

using Microsoft.VisualStudio.TestTools.UnitTesting;
using SampleClassLib;
using System;
using System.Windows.Forms;

namespace TestNamespace
{
    [TestClass()]
    public sealed class DivideClassTest
    {
        [AssemblyInitialize()]
        public static void AssemblyInit(TestContext context)
        {
            MessageBox.Show("AssemblyInit " + context.TestName);
        }

        [ClassInitialize()]
        public static void ClassInit(TestContext context)
        {
            MessageBox.Show("ClassInit " + context.TestName);
        }

        [TestInitialize()]
        public void Initialize()
        {
            MessageBox.Show("TestMethodInit");
        }

        [TestCleanup()]
        public void Cleanup()
        {
            MessageBox.Show("TestMethodCleanup");
        }

        [ClassCleanup()]
        public static void ClassCleanup()
        {
            MessageBox.Show("ClassCleanup");
        }

        [AssemblyCleanup()]
        public static void AssemblyCleanup()
        {
            MessageBox.Show("AssemblyCleanup");
        }

        [TestMethod()]
        [ExpectedException(typeof(System.DivideByZeroException))]
        public void DivideMethodTest()
        {
            DivideClass.DivideMethod(0);
        }
    }
}

Imports Microsoft.VisualStudio.TestTools.UnitTesting
Imports SampleClassLib2.SampleClassLib
Imports System
Imports System.IO
Imports System.Windows.Forms

Namespace TestNamespace
    <TestClass()> _
    Public NotInheritable Class DivideClassTest
        <AssemblyInitialize()> _
        Public Shared Sub AssemblyInit(ByVal context As TestContext)
            MsgBox("AssemblyInit " + context.TestName)
        End Sub 'AssemblyInit

        <ClassInitialize()> _
        Public Shared Sub ClassInit(ByVal context As TestContext)
            MsgBox("ClassInit " + context.TestName)
        End Sub 'ClassInit

        <TestInitialize()> _
        Public Sub Initialize()
            MsgBox("TestMethodInit")
        End Sub 

        <TestCleanup()> _
        Public Sub Cleanup()
            MsgBox("TestMethodCleanup")
        End Sub 

        <ClassCleanup()> _
        Public Shared Sub ClassCleanup()
            MsgBox("ClassCleanup")
        End Sub 

        <AssemblyCleanup()> _
        Public Shared Sub AssemblyCleanup()
            MsgBox("AssemblyCleanup")
        End Sub

        <TestMethod()> _
        <ExpectedException(GetType(System.DivideByZeroException))> _
        Public Sub DivideMethodTest()
            DivideClass.DivideMethod(0)
        End Sub
    End Class
End Namespace