CodeClass2.AddStruct(String, Object, Object, Object, vsCMAccess) Método

Definição

Cria uma nova estrutura na classe.

EnvDTE::CodeStruct AddStruct(std::wstring const & Name, winrt::Windows::Foundation::IInspectable const & Position, winrt::Windows::Foundation::IInspectable const & Bases, winrt::Windows::Foundation::IInspectable const & ImplementedInterfaces, EnvDTE::vsCMAccess Access = EnvDTE.vsCMAccess.vsCMAccessDefault);
[System.Runtime.InteropServices.DispId(68)]
public EnvDTE.CodeStruct AddStruct (string Name, object Position, object Bases, object ImplementedInterfaces, EnvDTE.vsCMAccess Access = EnvDTE.vsCMAccess.vsCMAccessDefault);
[<System.Runtime.InteropServices.DispId(68)>]
abstract member AddStruct : string * obj * obj * obj * EnvDTE.vsCMAccess -> EnvDTE.CodeStruct
Public Function AddStruct (Name As String, Optional Position As Object, Optional Bases As Object, Optional ImplementedInterfaces As Object, Optional Access As vsCMAccess = EnvDTE.vsCMAccess.vsCMAccessDefault) As CodeStruct

Parâmetros

Name
String

Obrigatórios. O nome da nova estrutura.

Position
Object

Opcional. Padrão = 0. O elemento de código depois do qual adicionar o novo elemento.

Se o valor for um tipo de dados longo, o método Position indicará o elemento depois do qual adicionar o novo elemento.

Como as coleções começam sua contagem em 1, passar 0 indica que o novo elemento deve ser colocado no início da coleção. Um valor de-1 significa que o elemento deve ser posicionado no final.

Bases
Object

Obrigatórios. O valor padrão é Nothing. Uma variante que contém um SafeArray de nomes de tipo totalmente qualificados ou CodeInterface objetos dos quais a nova estrutura deriva.

ImplementedInterfaces
Object

Obrigatórios. O valor padrão é Nothing. Uma SafeArray de nomes de tipo totalmente qualificados ou CodeInterface objetos que representam interfaces que a nova classe promete implementar.

Access
vsCMAccess

Opcional. Uma constante vsCMAccess.

Retornos

CodeStruct

Um objeto CodeStruct.

Implementações

Atributos

Exemplos

[Visual Basic]

Sub AddStructExample(ByVal dte As DTE2)  
    ' Before running this example, open a code document from a project.  
    Try  
        Dim projItem As ProjectItem = dte.ActiveDocument.ProjectItem  
        Dim cm As CodeModel = projItem.ContainingProject.CodeModel  

        ' Initialize the base classes array and the implemented   
        ' interfaces array.  
        Dim bases() As Object = {ConvertFullName(cm, "System.Object")}  
        Dim interfaces() As Object = { _  
            ConvertFullName(cm, "System.IDisposable"), _  
            ConvertFullName(cm, "System.IComparable") _  
        }  

        ' Create a new struct.  
        cm.AddStruct("TestStruct", projItem.Name, , bases, interfaces)  
    Catch ex As Exception  
        MsgBox(ex.Message)  
    End Try  
End Sub  

Function ConvertFullName(ByVal cm As CodeModel, _  
    ByVal fullName As String) As String  
    ' Convert a .NET type name into a C++ type name.  
    If (cm.Language = CodeModelLanguageConstants.vsCMLanguageVC) Or _  
        (cm.Language = CodeModelLanguageConstants.vsCMLanguageMC) Then  
        Return fullName.Replace(".", "::")  
    Else  
        Return fullName  
    End If  
End Function  

[C#]

public void AddStructExample(DTE2 dte)  
{  
    // Before running this example, open a code document from   
    // a project.  
    try  
    {  
        ProjectItem projItem = dte.ActiveDocument.ProjectItem;  
        CodeModel cm = projItem.ContainingProject.CodeModel;  

        // Initialize the base classes array and the implemented   
        // interfaces array.  
        object[] bases = {ConvertFullName(cm, "System.Object")};  
        object[] interfaces = {  
            ConvertFullName(cm, "System.IDisposable"),  
            ConvertFullName(cm, "System.IComparable")  
        };  

        // Create a new struct.  
        cm.AddStruct("TestStruct", projItem.Name, -1, bases,   
            interfaces, vsCMAccess.vsCMAccessPublic);  
    }  
    catch (Exception ex)  
    {  
        MessageBox.Show(ex.Message);  
    }  
}  

string ConvertFullName(CodeModel cm, string fullName)  
{  
    // Convert a .NET type name into a C++ type name.  
    if ((cm.Language == CodeModelLanguageConstants.vsCMLanguageVC) ||   
        (cm.Language == CodeModelLanguageConstants.vsCMLanguageMC))  
        return fullName.Replace(".", "::");  
    else  
        return fullName;  
}  

Comentários

O Visual C++ nativo requer os dois-pontos separados (::) formato para seus nomes de tipo totalmente qualificados. Todos os outros idiomas dão suporte ao formato separado por período.

A exatidão dos argumentos é determinada pelo idioma por trás do modelo de código.

Observação

Os valores dos elementos de modelo de código, como classes, structs, funções, atributos, delegados e assim por diante, podem ser não determinísticos depois de fazer determinados tipos de edições, o que significa que seus valores não podem ser dependentes para sempre permanecerem os mesmos. Para obter mais informações, consulte os valores de elemento de modelo de código de seção podem ser alterados na descoberta de código usando o modelo de código (Visual Basic).

Aplica-se a