CodeAttribute2.AddArgument(String, Object, Object) Method

Definition

Namespace:

EnvDTE80

Assembly:

Microsoft.VisualStudio.Interop.dll

Adds an argument to the attribute.

EnvDTE80::CodeAttributeArgument AddArgument(std::wstring const & Value, winrt::Windows::Foundation::IInspectable const & Name, winrt::Windows::Foundation::IInspectable const & Position);

[System.Runtime.InteropServices.DispId(201)]
public EnvDTE80.CodeAttributeArgument AddArgument (string Value, object Name, object Position);

[<System.Runtime.InteropServices.DispId(201)>]
abstract member AddArgument : string * obj * obj -> EnvDTE80.CodeAttributeArgument

Public Function AddArgument (Value As String, Optional Name As Object, Optional Position As Object) As CodeAttributeArgument

Parameters

Value

String

Required. Default value is 0.The element after which to add the new element. If the value is a CodeElement, then the new element is added after the argument, CodeElement. If the value is a Long data type, then it indicates the element after which to add the new one. Because collections are one-based, passing zero indicates that the new element should be placed at the beginning of the collection. A value of -1 means to put the argument at the end.

Name

Object

Required. The value of the argument.

Position

Object

Optional. If the argument is a named parameter, this parameter contains the name of the argument.

Returns

CodeAttributeArgument

A CodeAttributeArgument object.

Attributes

DispIdAttribute

Examples

The following example creates a new namespace and attribute in the current class and lists some of the attribute's properties.

public void CreateClassAndAttrib(DTE2 applicationObject)  
{  
    // Before running, load or create a project.  
    FileCodeModel2 fcm2 = GetFileCodeModel(applicationObject);  
    CodeAttribute2 cmAttribute;  
    CodeClass2 cmClass;  
    String msg = null;  

    if (fcm2 != null)  
    {  
        CodeNamespace cmNamespace;  
        // Try to create a new namespace.  
        try  
        {  
            cmNamespace = fcm2.AddNamespace("CMNamespace", -1);  
            // If successful, create the other code elements.  
            if (cmNamespace != null)  
            {  
                cmClass = (CodeClass2)cmNamespace.AddClass("ANewClass",   
                -1, null, null, vsCMAccess.vsCMAccessPrivate);  
                cmAttribute = (CodeAttribute2)cmClass.AddAttribute  
                ("NewAttribute", "AttributeValue", -1);  
                msg += "# of Arguments: " + cmAttribute.Arguments.Count   
                + Environment.NewLine;  
                MessageBox.Show(msg);  
                cmAttribute.AddArgument("NewAddedValue", null, null);  
                msg += "# of Arguments: " + cmAttribute.Arguments.Count   
                + Environment.NewLine;  
                MessageBox.Show(msg);                         
            }  
            else  
            {  
                MessageBox.Show("Cannot continue - no filecodemodel   
                available.");  
            }  
        }  
        catch (Exception ex)  
        {  
            MessageBox.Show("ERROR: " + ex);  
        }  
    }  
}  

public FileCodeModel2 GetFileCodeModel(DTE2 applicationObject)  
{  
    // Returns the FileCodeModel object of the active   
    // window.  
    TextWindow txtWin =   
    (TextWindow)applicationObject.ActiveWindow.Object;  
    FileCodeModel2 fcm2;  
    if (txtWin != null)  
    {  
        try  
        {  
             fcm2 = (FileCodeModel2)txtWin.Parent.  
             ProjectItem.FileCodeModel;  
             return fcm2;  
        }  
        catch (Exception ex)  
        {  
             MessageBox.Show("ERROR: " + ex);  
             return null;  
        }  
    }  
    else  
        return null;  
}  

Remarks

Note

Code attribute argument values, after being assigned, are not retained in memory by Visual Studio, and thus, may or may not be valid when a future update to the code attribute argument occurs. That is, a subsequent argument access may return E_FAIL or a totally different value. (Anything that affects the element's children, however, does not have this problem.)

Because of this non-deterministic behavior, you should retrieve the argument's value prior to changing it. For example, if you set a code attribute argument in your code, such as myAttrArg.Value = """a first value""", then you should explicitly reference it before updating it, such as myAttrArg = myAttr.Arguments.Item("first value"), and then assign the new value, myAttrArg.Value = """a second value""". Doing this ensures that the correct argument is changed.

Also, the values of code model elements such as classes, structs, functions, attributes, delegates, and so forth can be non-deterministic after making certain kinds of edits, meaning that their values cannot be relied upon to always remain the same. For more information, see the section Code Model Element Values Can Change in Discovering Code by Using the Code Model (Visual Basic).