Office.Document interface

Referenz

Paket:: office

Eine abstrakte Klasse, die das Dokument darstellt, mit dem das Add-In interagiert.

Hinweise

Anwendungen: Excel, PowerPoint, Project, Word

Beispiele

// Get the Document object with the Common APIs.
const document : Office.Document = Office.context.document;

Eigenschaften

bindings	Ruft ein Objekt ab, das Zugriff auf die im Dokument definierten Bindungen bereitstellt.
customXmlParts	Ruft ein Objekt ab, das die benutzerdefinierten XML-Komponenten im Dokument darstellt.
mode	Ruft den Modus ab, in dem sich das Dokument befindet.
settings	Ruft ein Objekt ab, das die gespeicherten benutzerdefinierten Einstellungen des Inhalts- oder Aufgabenbereichs-Add-Ins für das aktuelle Dokument darstellt.
url	Ruft die URL des Dokuments ab, das die Office-Anwendung derzeit geöffnet hat. Gibt null zurück, wenn die URL nicht verfügbar ist.

Methoden

addHandlerAsync(eventType, handler, options, callback)	Fügt einen Ereignishandler für ein Document-Objektereignis hinzu.
addHandlerAsync(eventType, handler, callback)	Fügt einen Ereignishandler für ein Document-Objektereignis hinzu.
getActiveViewAsync(options, callback)	Gibt den Status der aktuellen Ansicht der Präsentation ("Bearbeiten" oder "Lesen") zurück.
getActiveViewAsync(callback)	Gibt den Status der aktuellen Ansicht der Präsentation ("Bearbeiten" oder "Lesen") zurück.
getFileAsync(fileType, options, callback)	Gibt die gesamte Dokumentdatei in Segmenten von bis zu 4194304 Byte (4 MB) zurück. Für Add-Ins auf dem iPad wird der Dateislice bis zu 65536 (64 KB) unterstützt. Beachten Sie, dass Angabe einer Foliendateigröße oberhalb des zulässigen Grenzwerts zu einem "Internen Fehler" führt.
getFileAsync(fileType, callback)	Gibt die gesamte Dokumentdatei in Segmenten von bis zu 4194304 Byte (4 MB) zurück. Für Add-Ins auf dem iPad wird der Dateislice bis zu 65536 (64 KB) unterstützt. Beachten Sie, dass Angabe einer Foliendateigröße oberhalb des zulässigen Grenzwerts zu einem "Internen Fehler" führt.
getFilePropertiesAsync(options, callback)	Ruft Dateieigenschaften des aktuellen Dokuments ab.
getFilePropertiesAsync(callback)	Ruft Dateieigenschaften des aktuellen Dokuments ab.
getMaxResourceIndexAsync(options, callback)	Nur Projektdokumente. Ruft den maximalen Index der Auflistung von Ressourcen im aktuellen Projekt ab. Wichtig: Diese API funktioniert nur in Project 2016 auf Dem Windows-Desktop.
getMaxResourceIndexAsync(callback)	Nur Projektdokumente. Ruft den maximalen Index der Auflistung von Ressourcen im aktuellen Projekt ab. Wichtig: Diese API funktioniert nur in Project 2016 auf Dem Windows-Desktop.
getMaxTaskIndexAsync(options, callback)	Nur Projektdokumente. Ruft den maximalen Index der Auflistung von Vorgängen im aktuellen Projekt ab. Wichtig: Diese API funktioniert nur in Project 2016 auf Dem Windows-Desktop.
getMaxTaskIndexAsync(callback)	Nur Projektdokumente. Ruft den maximalen Index der Auflistung von Vorgängen im aktuellen Projekt ab. Wichtig: Diese API funktioniert nur in Project 2016 auf Dem Windows-Desktop.
getProjectFieldAsync(fieldId, options, callback)	Nur Projektdokumente. Projektfeld abrufen (z. B. ProjectWebAccessURL).
getProjectFieldAsync(fieldId, callback)	Nur Projektdokumente. Projektfeld abrufen (z. B. ProjectWebAccessURL).
getResourceByIndexAsync(resourceIndex, options, callback)	Nur Projektdokumente. Rufen Sie die GUID der Ressource ab, die den angegebenen Index in der Ressourcenauflistung aufweist. Wichtig: Diese API funktioniert nur in Project 2016 auf Dem Windows-Desktop.
getResourceByIndexAsync(resourceIndex, callback)	Nur Projektdokumente. Rufen Sie die GUID der Ressource ab, die den angegebenen Index in der Ressourcenauflistung aufweist. Wichtig: Diese API funktioniert nur in Project 2016 auf Dem Windows-Desktop.
getResourceFieldAsync(resourceId, fieldId, options, callback)	Nur Projektdokumente. Abrufen des Ressourcenfelds für die angegebene Ressourcen-ID. (z. B. ResourceName)
getResourceFieldAsync(resourceId, fieldId, callback)	Nur Projektdokumente. Abrufen des Ressourcenfelds für die angegebene Ressourcen-ID. (z. B. ResourceName)
getSelectedDataAsync(coercionType, options, callback)	Liest die Daten, die in der aktuellen Auswahl des Dokuments enthalten sind.
getSelectedDataAsync(coercionType, callback)	Liest die Daten, die in der aktuellen Auswahl des Dokuments enthalten sind.
getSelectedResourceAsync(options, callback)	Nur Projektdokumente. Ruft die ID der aktuell ausgewählten Ressource ab.
getSelectedResourceAsync(callback)	Nur Projektdokumente. Ruft die ID der aktuell ausgewählten Ressource ab.
getSelectedTaskAsync(options, callback)	Nur Projektdokumente. Ruft die ID der aktuell ausgewählten Aufgabe ab.
getSelectedTaskAsync(callback)	Nur Projektdokumente. Ruft die ID der aktuell ausgewählten Aufgabe ab.
getSelectedViewAsync(options, callback)	Nur Projektdokumente. Rufen Sie den aktuell ausgewählten Ansichtstyp (z. B. Gantt) und ansichtsnamen ab.
getSelectedViewAsync(callback)	Nur Projektdokumente. Rufen Sie den aktuell ausgewählten Ansichtstyp (z. B. Gantt) und ansichtsnamen ab.
getTaskAsync(taskId, options, callback)	Nur Projektdokumente. Rufen Sie den Vorgangsnamen, die WSS-Vorgangs-ID und die Ressourcennamen für die angegebene taskId ab.
getTaskAsync(taskId, callback)	Nur Projektdokumente. Rufen Sie den Vorgangsnamen, die WSS-Vorgangs-ID und die Ressourcennamen für die angegebene taskId ab.
getTaskByIndexAsync(taskIndex, options, callback)	Nur Projektdokumente. Ruft die GUID des Tasks ab, der den angegebenen Index in der Aufgabenauflistung aufweist. Wichtig: Diese API funktioniert nur in Project 2016 auf Dem Windows-Desktop.
getTaskByIndexAsync(taskIndex, callback)	Nur Projektdokumente. Ruft die GUID des Tasks ab, der den angegebenen Index in der Aufgabenauflistung aufweist. Wichtig: Diese API funktioniert nur in Project 2016 auf Dem Windows-Desktop.
getTaskFieldAsync(taskId, fieldId, options, callback)	Nur Projektdokumente. Dient zum Abrufen des Vorgangsfelds für die angegebene Vorgangs-ID. (z. B. StartDate).
getTaskFieldAsync(taskId, fieldId, callback)	Nur Projektdokumente. Dient zum Abrufen des Vorgangsfelds für die angegebene Vorgangs-ID. (z. B. StartDate).
getWSSUrlAsync(options, callback)	Nur Projektdokumente. Rufen Sie die WSS-URL und den Listennamen für die Aufgabenliste ab. Das MPP wird ebenfalls synchronisiert.
getWSSUrlAsync(callback)	Nur Projektdokumente. Rufen Sie die WSS-URL und den Listennamen für die Aufgabenliste ab. Das MPP wird ebenfalls synchronisiert.
goToByIdAsync(id, goToType, options, callback)	Wechselt zum angegebenen Objekt oder Speicherort im Dokument.
goToByIdAsync(id, goToType, callback)	Wechselt zum angegebenen Objekt oder Speicherort im Dokument.
removeHandlerAsync(eventType, options, callback)	Entfernt einen Ereignishandler für den angegebenen Ereignistyp.
removeHandlerAsync(eventType, callback)	Entfernt einen Ereignishandler für den angegebenen Ereignistyp.
setResourceFieldAsync(resourceId, fieldId, fieldValue, options, callback)	Nur Projektdokumente. Legen Sie das Ressourcenfeld für die angegebene Ressourcen-ID fest. Wichtig: Diese API funktioniert nur in Project 2016 auf Dem Windows-Desktop.
setResourceFieldAsync(resourceId, fieldId, fieldValue, callback)	Nur Projektdokumente. Legen Sie das Ressourcenfeld für die angegebene Ressourcen-ID fest. Wichtig: Diese API funktioniert nur in Project 2016 auf Dem Windows-Desktop.
setSelectedDataAsync(data, options, callback)	Schreibt die angegebenen Daten in die aktuelle Auswahl.
setSelectedDataAsync(data, callback)	Schreibt die angegebenen Daten in die aktuelle Auswahl.
setTaskFieldAsync(taskId, fieldId, fieldValue, options, callback)	Nur Projektdokumente. Legen Sie das Vorgangsfeld für die angegebene Vorgangs-ID fest. Wichtig: Diese API funktioniert nur in Project 2016 auf Dem Windows-Desktop.
setTaskFieldAsync(taskId, fieldId, fieldValue, callback)	Nur Projektdokumente. Legen Sie das Vorgangsfeld für die angegebene Vorgangs-ID fest. Wichtig: Diese API funktioniert nur in Project 2016 auf Dem Windows-Desktop.

Details zur Eigenschaft

bindings

Ruft ein Objekt ab, das Zugriff auf die im Dokument definierten Bindungen bereitstellt.

bindings: Bindings;

Eigenschaftswert

Office.Bindings

Hinweise

Sie instanziieren das Document-Objekt nicht direkt in Ihrem Skript. Verwenden Sie zum Aufrufen von Elementen des Document-Objekts, die mit dem aktuellen Dokument oder Arbeitsblatt interagieren sollen, in Ihrem Skript Office.context.document.

Beispiele

function displayAllBindings() {
    Office.context.document.bindings.getAllAsync(function (asyncResult) {
        let bindingString = '';
        for (let i in asyncResult.value) {
            bindingString += asyncResult.value[i].id + '\n';
        }
        write('Existing bindings: ' + bindingString);
    });
}

// Function that writes to a div with id='message' on the page.
function write(message){
    document.getElementById('message').innerText += message; 
}

customXmlParts

Ruft ein Objekt ab, das die benutzerdefinierten XML-Komponenten im Dokument darstellt.

customXmlParts: CustomXmlParts;

Eigenschaftswert

Office.CustomXmlParts

Beispiele

function getCustomXmlParts(){
    Office.context.document.customXmlParts.getByNamespaceAsync('http://tempuri.org', function (asyncResult) {
        write('Retrieved ' + asyncResult.value.length + ' custom XML parts');
    });
}

// Function that writes to a div with id='message' on the page.
function write(message){
    document.getElementById('message').innerText += message; 
}

mode

Ruft den Modus ab, in dem sich das Dokument befindet.

mode: DocumentMode;

Eigenschaftswert

Office.DocumentMode

Beispiele

function displayDocumentMode() {
    write(Office.context.document.mode);
}

// Function that writes to a div with id='message' on the page.
function write(message){
    document.getElementById('message').innerText += message; 
}

// The following example initializes the add-in and then gets properties of the
// Document object that are available in the context of a Project document.
// A Project document is the opened, active project. To access members of the
// ProjectDocument object, use the Office.context.document object as shown in
// the code examples for ProjectDocument methods and events.
// The example assumes your add-in has a reference to the jQuery library and
// that the following page control is defined in the content div in the page body:
// <span id="message"></span>

(function () {
    "use strict";

    // The initialize function must be run each time a new page is loaded.
    Office.initialize = function (reason) {
        $(document).ready(function () {

            // Get information about the document.
            showDocumentProperties();
        });
    };

    // Get the document mode and the URL of the active project.
    function showDocumentProperties() {
        const output = String.format(
            'The document mode is {0}.<br/>The URL of the active project is {1}.',
            Office.context.document.mode,
            Office.context.document.url);
        $('#message').html(output);
    }
})();

settings

Ruft ein Objekt ab, das die gespeicherten benutzerdefinierten Einstellungen des Inhalts- oder Aufgabenbereichs-Add-Ins für das aktuelle Dokument darstellt.

settings: Settings;

Eigenschaftswert

Office.Settings

url

Ruft die URL des Dokuments ab, das die Office-Anwendung derzeit geöffnet hat. Gibt null zurück, wenn die URL nicht verfügbar ist.

url: string;

Eigenschaftswert

string

Beispiele

function displayDocumentUrl() {
    write(Office.context.document.url);
}

// Function that writes to a div with id='message' on the page.
function write(message){
    document.getElementById('message').innerText += message; 
}

Details zur Methode

addHandlerAsync(eventType, handler, options, callback)

Fügt einen Ereignishandler für ein Document-Objektereignis hinzu.

addHandlerAsync(eventType: Office.EventType, handler: any, options?: Office.AsyncContextOptions, callback?: (result: AsyncResult<void>) => void): void;

Parameter

eventType: Office.EventType

Für ein Document-Objektereignis kann der eventType-Parameter als Office.EventType.Document.SelectionChanged oder Office.EventType.Document.ActiveViewChangedoder als der entsprechende Textwert dieser Enumeration angegeben werden.

handler: any

Die hinzuzufügende Ereignishandlerfunktion, deren einziger Parameter vom Typ Office.DocumentSelectionChangedEventArgs ist. Erforderlich.

options: Office.AsyncContextOptions

Bietet eine Option zum Beibehalten von Kontextdaten eines beliebigen Typs , unverändert, für die Verwendung in einem Rückruf.

callback: (result: Office.AsyncResult<void>) => void

Optional. Eine Funktion, die aufgerufen wird, wenn der Rückruf zurückgibt, deren einziger Parameter vom Typ Office.AsyncResult ist.

Gibt zurück

void

Hinweise

Anforderungssatz: DocumentEvents

Sie können mehrere Ereignishandler für den angegebenen eventType hinzufügen, solange der Name jeder Ereignishandlerfunktion eindeutig ist.

addHandlerAsync(eventType, handler, callback)

Fügt einen Ereignishandler für ein Document-Objektereignis hinzu.

addHandlerAsync(eventType: Office.EventType, handler: any, callback?: (result: AsyncResult<void>) => void): void;

Parameter

eventType: Office.EventType

handler: any

Die hinzuzufügende Ereignishandlerfunktion, deren einziger Parameter vom Typ Office.DocumentSelectionChangedEventArgs ist. Erforderlich.

callback: (result: Office.AsyncResult<void>) => void

Optional. Eine Funktion, die aufgerufen wird, wenn der Rückruf zurückgibt, deren einziger Parameter vom Typ Office.AsyncResult ist.

Gibt zurück

void

Hinweise

Anforderungssatz: DocumentEvents

Sie können mehrere Ereignishandler für den angegebenen eventType hinzufügen, solange der Name jeder Ereignishandlerfunktion eindeutig ist.

Beispiele

// The following example adds an event handler for the SelectionChanged event of a document
function addSelectionChangedEventHandler() {
    Office.context.document.addHandlerAsync(Office.EventType.DocumentSelectionChanged, MyHandler);
}

function MyHandler(eventArgs) {
    write('Event raised: ' + eventArgs.type);
    doSomethingWithDocument(eventArgs.document);
}

// Function that writes to a div with id='message' on the page.
function write(message){
    document.getElementById('message').innerText += message; 
}

// The following code example adds a handler for the ResourceSelectionChanged event.
// When the resource selection changes in the document, it gets the GUID of the selected resource.
// The example assumes your add-in has a reference to the jQuery library and that the
// following page control is defined in the content div in the page body:
// <span id="message"></span>

(function () {
    "use strict";

    // The initialize function must be run each time a new page is loaded.
    Office.initialize = function (reason) {
        $(document).ready(function () {

            // After the DOM is loaded, add-in-specific code can run.
            Office.context.document.addHandlerAsync(
                Office.EventType.ResourceSelectionChanged,
                getResourceGuid);
        });
    };

    // Get the GUID of the selected resource and display it in the add-in.
    function getResourceGuid() {
        Office.context.document.getSelectedResourceAsync(
            function (result) {
                if (result.status === Office.AsyncResultStatus.Failed) {
                    onError(result.error);
                }
                else {
                    $('#message').html(result.value);
                }
            }
        );
    }

    function onError(error) {
        $('#message').html(error.name + ' ' + error.code + ': ' + error.message);
    }
})();

// For a complete code sample that shows how to use a ResourceSelectionChanged
// event handler in a Project add-in, see "Create your first task pane add-in for Microsoft Project".
// https://learn.microsoft.com/office/dev/add-ins/project/create-your-first-task-pane-add-in-for-project-by-using-a-text-editor

// The following code example adds a handler for the TaskSelectionChanged event.
// When the task selection changes in the document, it gets the GUID of the
// selected task.
// The example assumes your add-in has a reference to the jQuery library and that
// the following page control is defined in the content div in the page body:
// <span id="message"></span>

(function () {
    "use strict";

    // The initialize function must be run each time a new page is loaded.
    Office.initialize = function (reason) {
        $(document).ready(function () {

            // After the DOM is loaded, add-in-specific code can run.
            Office.context.document.addHandlerAsync(
                Office.EventType.TaskSelectionChanged,
                getTaskGuid);
            getTaskGuid();
        });
    };

    // Get the GUID of the selected task and display it in the add-in.
    function getTaskGuid() {
        Office.context.document.getSelectedTaskAsync(
            function (result) {
                if (result.status === Office.AsyncResultStatus.Failed) {
                    onError(result.error);
                }
                else {
                    $('#message').html(result.value);
                }
            }
        );
    }

    function onError(error) {
        $('#message').html(error.name + ' ' + error.code + ': ' + error.message);
    }
})();

// The following code example adds a handler for the ViewSelectionChanged
// event. When the active view changes, it gets the name and type of the active view.
// The example assumes your add-in has a reference to the jQuery library and that
// the following page control is defined in the content div in the page body:
// <span id="message"></span>

(function () {
    "use strict";

    // The initialize function must be run each time a new page is loaded.
    Office.initialize = function (reason) {
        $(document).ready(function () {

            // After the DOM is loaded, add-in-specific code can run.
            Office.context.document.addHandlerAsync(
                Office.EventType.ViewSelectionChanged,
                getActiveView);
            getActiveView();
        });
    };

    // Get the name and type of the active view and display it in the add-in.
    function getActiveView() {
        Office.context.document.getSelectedViewAsync(
            function (result) {
                if (result.status === Office.AsyncResultStatus.Failed) {
                    onError(result.error);
                }
                else {
                    const output = String.format(
                        'View name: {0}<br/>View type: {1}',
                        result.value.viewName, result.value.viewType);
                    $('#message').html(output);
                }
            }
        );
    }

    function onError(error) {
        $('#message').html(error.name + ' ' + error.code + ': ' + error.message);
    }
})();

// For an example that shows how to use a ViewSelectionChanged event handler in a
// Project add-in, see "Create your first task pane add-in for Microsoft Project".
// https://learn.microsoft.com/office/dev/add-ins/project/create-your-first-task-pane-add-in-for-project-by-using-a-text-editor

// The following code example uses addHandlerAsync to add an event handler for the ViewSelectionChanged event.
// When the active view changes, the handler checks the view type. It enables a button if the view is a resource
// view and disables the button if it isn't a resource view. Choosing the button gets the GUID of the selected
// resource and displays it in the add-in.
// The example assumes that your add-in has a reference to the jQuery library and that the following page controls
// are defined in the content div in the page body:
// <input id="get-info" type="button" value="Get info" disabled="disabled" /><br />
// <span id="message"></span>

(function () {
    "use strict";

    // The initialize function must be run each time a new page is loaded.
    Office.initialize = function (reason) {
        $(document).ready(function () {

            // After the DOM is loaded, add-in-specific code can run.
            // Add a ViewSelectionChanged event handler.
            Office.context.document.addHandlerAsync(
                Office.EventType.ViewSelectionChanged,
                getActiveView);
            $('#get-info').on("click", getResourceGuid);

            // This example calls the handler on page load to get the active view
            // of the default page.
            getActiveView();
        });
    };

    // Activate the button based on the active view type of the document.
    // This is the ViewSelectionChanged event handler.
    function getActiveView() {
        Office.context.document.getSelectedViewAsync(
            function (result) {
                if (result.status === Office.AsyncResultStatus.Failed) {
                    onError(result.error);
                }
                else {
                    const viewType = result.value.viewType;
                    if (viewType == 6 ||   // ResourceForm
                        viewType == 7 ||   // ResourceSheet
                        viewType == 8 ||   // ResourceGraph
                        viewType == 15) {  // ResourceUsage
                        $('#get-info').removeAttr('disabled');
                    }
                    else {
                        $('#get-info').attr('disabled', 'disabled');
                    }
                    const output = String.format(
                        'View name: {0}<br/>View type: {1}',
                        result.value.viewName, viewType);
                    $('#message').html(output);
                }
            }
        );
    }

    // Get the GUID of the currently selected resource and display it in the add-in.
    function getResourceGuid() {
        Office.context.document.getSelectedResourceAsync(
            function (result) {
                if (result.status === Office.AsyncResultStatus.Failed) {
                    onError(result.error);
                }
                else {
                    $('#message').html('Resource GUID: ' + result.value);
                }
            }
        );
    }

    function onError(error) {
        $('#message').html(error.name + ' ' + error.code + ': ' + error.message);
    }
})();

// For a complete code sample that shows how to use a ViewSelectionChanged event handler in a Project add-in,
// see "Create your first task pane add-in for Project by using a text editor."
// https://learn.microsoft.com/office/dev/add-ins/project/create-your-first-task-pane-add-in-for-project-by-using-a-text-editor

getActiveViewAsync(options, callback)

Gibt den Status der aktuellen Ansicht der Präsentation ("Bearbeiten" oder "Lesen") zurück.

getActiveViewAsync(options?: Office.AsyncContextOptions, callback?: (result: AsyncResult<"edit" | "read">) => void): void;

Parameter

options: Office.AsyncContextOptions

Bietet eine Option zum Beibehalten von Kontextdaten eines beliebigen Typs , unverändert, für die Verwendung in einem Rückruf.

callback: (result: Office.AsyncResult<"edit" | "read">) => void

Optional. Eine Funktion, die aufgerufen wird, wenn der Rückruf zurückgibt, deren einziger Parameter vom Typ Office.AsyncResult ist. Die value -Eigenschaft des Ergebnisses ist der Zustand der aktuellen Ansicht der Präsentation. Der zurückgegebene Wert kann entweder "edit" oder "read" lauten. "Bearbeiten" entspricht einer der Ansichten, in denen Sie Folien bearbeiten können: Normal, Foliensortierung oder Gliederungsansicht. "lesen" entspricht entweder der Bildschirmpräsentation oder der Leseansicht.

Gibt zurück

void

Hinweise

Anforderungssatz: ActiveView

Kann ein Ereignis auslösen, wenn die Ansicht geändert wird.

getActiveViewAsync(callback)

Gibt den Status der aktuellen Ansicht der Präsentation ("Bearbeiten" oder "Lesen") zurück.

getActiveViewAsync(callback?: (result: AsyncResult<"edit" | "read">) => void): void;

Parameter

callback: (result: Office.AsyncResult<"edit" | "read">) => void

Gibt zurück

void

Hinweise

Anforderungssatz: ActiveView

Kann ein Ereignis auslösen, wenn die Ansicht geändert wird.

Beispiele

function getFileView() {
    // Get whether the current view is edit or read.
    Office.context.document.getActiveViewAsync(function (asyncResult) {
        if (asyncResult.status == "failed") {
            showMessage("Action failed with error: " + asyncResult.error.message);
        }
        else {
            showMessage(asyncResult.value);
        }
    });
}

getFileAsync(fileType, options, callback)

Gibt die gesamte Dokumentdatei in Segmenten von bis zu 4194304 Byte (4 MB) zurück. Für Add-Ins auf dem iPad wird der Dateislice bis zu 65536 (64 KB) unterstützt. Beachten Sie, dass Angabe einer Foliendateigröße oberhalb des zulässigen Grenzwerts zu einem "Internen Fehler" führt.

getFileAsync(fileType: FileType, options?: GetFileOptions, callback?: (result: AsyncResult<Office.File>) => void): void;

Parameter

fileType: Office.FileType

Das Format, in dem die Datei zurückgegeben wird

options: Office.GetFileOptions

Bietet Optionen zum Festlegen der Größe von Segmenten, in die das Dokument unterteilt wird.

callback: (result: Office.AsyncResult<Office.File>) => void

Optional. Eine Funktion, die aufgerufen wird, wenn der Rückruf zurückgibt, deren einziger Parameter vom Typ Office.AsyncResult ist. Die value -Eigenschaft des Ergebnisses ist das File-Objekt.

Gibt zurück

void

Hinweise

Anforderungssätze:

CompressedFile (bei Verwendung von Office.FileType.Compressed)
Datei
TextFile (bei Verwendung von Office.FileType.Text)

Für Add-Ins, die in anderen Office-Anwendungen als Office auf dem iPad ausgeführt werden, unterstützt die Methode das getFileAsync Abrufen von Dateien in Slices von bis zu 4194304 Bytes (4 MB). Für Add-Ins, die in Office-Apps auf dem iPad ausgeführt werden, unterstützt die Methode das getFileAsync Abrufen von Dateien in Segmenten von bis zu 65536 (64 KB).

Der fileType Parameter kann mithilfe der Office.FileType-Enumeration oder der Textwerte angegeben werden. Die möglichen Werte variieren jedoch je nach Anwendung.

Unterstützte Dateitypen nach Plattform

	Office unter Windows	Office im Web	Office auf dem iPad	Office für Mac
Excel	`Compressed`, `Pdf`, `Text`	`Compressed`, `Pdf`		`Compressed`, `Pdf`, `Text`
Powerpoint	`Compressed`, `Pdf`	`Compressed`, `Pdf`	`Compressed`, `Pdf`	`Compressed`, `Pdf`
Word	`Compressed`, `Pdf`, `Text`	`Compressed`, `Pdf`, `Text`	`Compressed`, `Pdf`	`Compressed`, `Pdf`, `Text`

Beispiele

// The following example gets the document in Office Open XML ("compressed") format in 65536 bytes (64 KB) slices.
// Note: The implementation of app.showNotification in this example is from the Visual Studio template for Office Add-ins.
function getDocumentAsCompressed() {
    Office.context.document.getFileAsync(Office.FileType.Compressed, { sliceSize: 65536 /*64 KB*/ }, 
        function (result) {
            if (result.status == "succeeded") {
                // If the getFileAsync call succeeded, then
                // result.value will return a valid File Object.
                const myFile = result.value;
                const sliceCount = myFile.sliceCount;
                const docDataSlices = [];
                let slicesReceived = 0, gotAllSlices = true;
                app.showNotification("File size:" + myFile.size + " #Slices: " + sliceCount);

                // Get the file slices.
                getSliceAsync(myFile, 0, sliceCount, gotAllSlices, docDataSlices, slicesReceived);
            } else {
                app.showNotification("Error:", result.error.message);
            }
    });
}

function getSliceAsync(file, nextSlice, sliceCount, gotAllSlices, docDataSlices, slicesReceived) {
    file.getSliceAsync(nextSlice, function (sliceResult) {
        if (sliceResult.status == "succeeded") {
            if (!gotAllSlices) { /* Failed to get all slices, no need to continue. */
                return;
            }

            // Got one slice, store it in a temporary array.
            // (Or you can do something else, such as
            // send it to a third-party server.)
            docDataSlices[sliceResult.value.index] = sliceResult.value.data;
            if (++slicesReceived == sliceCount) {
              // All slices have been received.
              file.closeAsync();
              onGotAllSlices(docDataSlices);
            }
            else {
                getSliceAsync(file, ++nextSlice, sliceCount, gotAllSlices, docDataSlices, slicesReceived);
            }
        }
            else {
                gotAllSlices = false;
                file.closeAsync();
                app.showNotification("getSliceAsync Error:", sliceResult.error.message);
            }
    });
}

function onGotAllSlices(docDataSlices) {
    let docData = [];
    for (let i = 0; i < docDataSlices.length; i++) {
        docData = docData.concat(docDataSlices[i]);
    }

    let fileContent = new String();
    for (let j = 0; j < docData.length; j++) {
        fileContent += String.fromCharCode(docData[j]);
    }

    // Now all the file content is stored in 'fileContent' variable,
    // you can do something with it, such as print, fax...
}

// The following example gets the document in PDF format.
Office.context.document.getFileAsync(Office.FileType.Pdf,
    function(result) {
        if (result.status == "succeeded") {
            const myFile = result.value;
            const sliceCount = myFile.sliceCount;
            app.showNotification("File size:" + myFile.size + " #Slices: " + sliceCount);

            // Get the file slices.
            const docDataSlices = [];
            let slicesReceived = 0, gotAllSlices = true;
            getSliceAsync(myFile, 0, sliceCount, gotAllSlices, docDataSlices, slicesReceived);
            
            myFile.closeAsync();
        }
        else {
            app.showNotification("Error:", result.error.message);
        }
    }
);

getFileAsync(fileType, callback)

getFileAsync(fileType: FileType, callback?: (result: AsyncResult<Office.File>) => void): void;

Parameter

fileType: Office.FileType

Das Format, in dem die Datei zurückgegeben wird

callback: (result: Office.AsyncResult<Office.File>) => void

Optional. Eine Funktion, die aufgerufen wird, wenn der Rückruf zurückgibt, deren einziger Parameter vom Typ Office.AsyncResult ist. Die value -Eigenschaft des Ergebnisses ist das File-Objekt.

Gibt zurück

void

Hinweise

Anforderungssätze:

CompressedFile (bei Verwendung von Office.FileType.Compressed)
Datei
TextFile (bei Verwendung von Office.FileType.Text)

Für Add-Ins, die in anderen Office-Anwendungen als Office auf dem iPad ausgeführt werden, unterstützt die Methode das getFileAsync Abrufen von Dateien in Slices von bis zu 4194304 Bytes (4 MB). Für Add-Ins, die in Office auf iPad-Apps ausgeführt werden, unterstützt die Methode das getFileAsync Abrufen von Dateien in Segmenten von bis zu 65536 (64 KB).

Der fileType Parameter kann mithilfe der Office.FileType-Enumeration oder der Textwerte angegeben werden. Die möglichen Werte variieren jedoch je nach Anwendung.

Unterstützte Dateitypen nach Plattform

	Office unter Windows	Office im Web	Office auf dem iPad	Office für Mac
Excel	`Compressed`, `Pdf`, `Text`	`Compressed`, `Pdf`		`Compressed`, `Pdf`, `Text`
Powerpoint	`Compressed`, `Pdf`	`Compressed`, `Pdf`	`Compressed`, `Pdf`	`Compressed`, `Pdf`
Word	`Compressed`, `Pdf`, `Text`	`Compressed`, `Pdf`, `Text`	`Compressed`, `Pdf`	`Compressed`, `Pdf`, `Text`

getFilePropertiesAsync(options, callback)

Ruft Dateieigenschaften des aktuellen Dokuments ab.

getFilePropertiesAsync(options?: Office.AsyncContextOptions, callback?: (result: AsyncResult<Office.FileProperties>) => void): void;

Parameter

options: Office.AsyncContextOptions

Bietet eine Option zum Beibehalten von Kontextdaten eines beliebigen Typs , unverändert, für die Verwendung in einem Rückruf.

callback: (result: Office.AsyncResult<Office.FileProperties>) => void

Eine Funktion, die aufgerufen wird, wenn der Rückruf zurückgibt, deren einziger Parameter vom Typ Office.AsyncResult ist. Die value -Eigenschaft des Ergebnisses sind die Eigenschaften der Datei (mit der URL unter asyncResult.value.url).

Gibt zurück

void

Hinweise

Anforderungssätze: Nicht in einem Satz

Sie erhalten die URL der Datei mit der URL-Eigenschaft asyncResult.value.url.

getFilePropertiesAsync(callback)

Ruft Dateieigenschaften des aktuellen Dokuments ab.

getFilePropertiesAsync(callback?: (result: AsyncResult<Office.FileProperties>) => void): void;

Parameter

callback: (result: Office.AsyncResult<Office.FileProperties>) => void

Gibt zurück

void

Hinweise

Anforderungssätze: Nicht in einem Satz

Sie erhalten die URL der Datei mit der URL-Eigenschaft asyncResult.value.url.

Beispiele

// To read the URL of the current file, you need to write a callback function that returns the URL.
// The following example shows how to:
// 1. Pass an anonymous callback function that returns the value of the file's URL
//    to the callback parameter of the getFilePropertiesAsync method.
// 2. Display the value on the add-in's page.
function getFileUrl() {
    // Get the URL of the current file.
    Office.context.document.getFilePropertiesAsync(function (asyncResult) {
        const fileUrl = asyncResult.value.url;
        if (fileUrl == "") {
            showMessage("The file hasn't been saved yet. Save the file and try again");
        }
        else {
            showMessage(fileUrl);
        }
    });
}

getMaxResourceIndexAsync(options, callback)

Nur Projektdokumente. Ruft den maximalen Index der Auflistung von Ressourcen im aktuellen Projekt ab.

Wichtig: Diese API funktioniert nur in Project 2016 auf Dem Windows-Desktop.

getMaxResourceIndexAsync(options?: Office.AsyncContextOptions, callback?: (result: AsyncResult<number>) => void): void;

Parameter

options: Office.AsyncContextOptions

Bietet eine Option zum Beibehalten von Kontextdaten eines beliebigen Typs , unverändert, für die Verwendung in einem Rückruf.

callback: (result: Office.AsyncResult<number>) => void

Gibt zurück

void

getMaxResourceIndexAsync(callback)

Nur Projektdokumente. Ruft den maximalen Index der Auflistung von Ressourcen im aktuellen Projekt ab.

Wichtig: Diese API funktioniert nur in Project 2016 auf Dem Windows-Desktop.

getMaxResourceIndexAsync(callback?: (result: AsyncResult<number>) => void): void;

Parameter

callback: (result: Office.AsyncResult<number>) => void

Gibt zurück

void

Beispiele

// The following code example calls getResourceTaskIndexAsync to get the maximum index of the collection 
// of resources in the current project. Then it uses the returned value and the getResourceByIndexAsync
// method to get each resource GUID. The example assumes that your add-in has a reference to the 
// jQuery library and that the following page controls are defined in the content div in the page body:
// <input id="get-info" type="button" value="Get info" /><br />
// <span id="message"></span>

(function () {
    "use strict";
    const resourceGuids = [];

    // The initialize function must be run each time a new page is loaded.
    Office.initialize = function (reason) {
        $(document).ready(function () {

            // After the DOM is loaded, add-in-specific code can run.
            app.initialize();
            $('#get-info').on("click", getResourceInfo);
        });
    };

    // Get the maximum resource index, and then get the resource GUIDs.
    function getResourceInfo() {
        getMaxResourceIndex().then(
            function (data) {
                getResourceGuids(data);
            }
        );
    }

    // Get the maximum index of the resources for the current project.
    function getMaxResourceIndex() {
        const defer = $.Deferred();
        Office.context.document.getMaxResourceIndexAsync(
            function (result) {
                if (result.status === Office.AsyncResultStatus.Failed) {
                    onError(result.error);
                }
                else {
                    defer.resolve(result.value);
                }
            }
        );
        return defer.promise();
    }

    // Get each resource GUID, and then display the GUIDs in the add-in.
    // There is no 0 index for resources, so start with index 1.
    function getResourceGuids(maxResourceIndex) {
        const defer = $.Deferred();
        for (let i = 1; i <= maxResourceIndex; i++) {
            getResourceGuid(i);
        }
        return defer.promise();
        function getResourceGuid(index) {
            Office.context.document.getResourceByIndexAsync(index,
                function (result) {
                    if (result.status === Office.AsyncResultStatus.Succeeded) {
                        resourceGuids.push(result.value);
                        if (index == maxResourceIndex) {
                            defer.resolve();
                            $('#message').html(resourceGuids.toString());
                        }
                    }
                    else {
                        onError(result.error);
                    }
                }
            );
        }
    }
    function onError(error) {
        app.showNotification(error.name + ' ' + error.code + ': ' + error.message);
    }
})();

getMaxTaskIndexAsync(options, callback)

Nur Projektdokumente. Ruft den maximalen Index der Auflistung von Vorgängen im aktuellen Projekt ab.

Wichtig: Diese API funktioniert nur in Project 2016 auf Dem Windows-Desktop.

getMaxTaskIndexAsync(options?: Office.AsyncContextOptions, callback?: (result: AsyncResult<number>) => void): void;

Parameter

options: Office.AsyncContextOptions

Bietet eine Option zum Beibehalten von Kontextdaten eines beliebigen Typs , unverändert, für die Verwendung in einem Rückruf.

callback: (result: Office.AsyncResult<number>) => void

Gibt zurück

void

getMaxTaskIndexAsync(callback)

Nur Projektdokumente. Ruft den maximalen Index der Auflistung von Vorgängen im aktuellen Projekt ab.

Wichtig: Diese API funktioniert nur in Project 2016 auf Dem Windows-Desktop.

getMaxTaskIndexAsync(callback?: (result: AsyncResult<number>) => void): void;

Parameter

callback: (result: Office.AsyncResult<number>) => void

Gibt zurück

void

Beispiele

// The following code example calls getMaxTaskIndexAsync to get the maximum index
// of the collection of tasks in the current project. Then it uses the returned value
// with the getTaskByIndexAsync method to get each task GUID.
// The example assumes your add-in has a reference to the jQuery library and that the
// following page controls are defined in the content div in the page body:
// <input id="get-info" type="button" value="Get info" /><br />
// <span id="message"></span>

(function () {
    "use strict";
    const taskGuids = [];

    // The initialize function must be run each time a new page is loaded.
    Office.initialize = function (reason) {
        $(document).ready(function () {

            // After the DOM is loaded, add-in-specific code can run.
            app.initialize();
            $('#get-info').on("click", getTaskInfo);
        });
    };

    // Get the maximum task index, and then get the task GUIDs.
    function getTaskInfo() {
        getMaxTaskIndex().then(
            function (data) {
                getTaskGuids(data);
            }
        );
    }

    // Get the maximum index of the tasks for the current project.
    function getMaxTaskIndex() {
        const defer = $.Deferred();
        Office.context.document.getMaxTaskIndexAsync(
            function (result) {
                if (result.status === Office.AsyncResultStatus.Failed) {
                    onError(result.error);
                }
                else {
                    defer.resolve(result.value);
                }
            }
        );
        return defer.promise();
    }

    // Get each task GUID, and then display the GUIDs in the add-in.
    function getTaskGuids(maxTaskIndex) {
        const defer = $.Deferred();
        for (let i = 0; i <= maxTaskIndex; i++) {
            getTaskGuid(i);
        }
        return defer.promise();
        function getTaskGuid(index) {
            Office.context.document.getTaskByIndexAsync(index,
                function (result) {
                    if (result.status === Office.AsyncResultStatus.Succeeded) {
                        taskGuids.push(result.value);
                        if (index == maxTaskIndex) {
                            defer.resolve();
                            $('#message').html(taskGuids.toString());
                        }
                    }
                    else {
                        onError(result.error);
                    }
                }
            );
        }
    }
    function onError(error) {
        app.showNotification(error.name + ' ' + error.code + ': ' + error.message);
    }
})();

getProjectFieldAsync(fieldId, options, callback)

Nur Projektdokumente. Projektfeld abrufen (z. B. ProjectWebAccessURL).

getProjectFieldAsync(fieldId: number, options?: Office.AsyncContextOptions, callback?: (result: AsyncResult<any>) => void): void;

Parameter

fieldId: number

Felder auf Projektebene.

options: Office.AsyncContextOptions

Bietet eine Option zum Beibehalten von Kontextdaten eines beliebigen Typs , unverändert, für die Verwendung in einem Rückruf.

callback: (result: Office.AsyncResult<any>) => void

Gibt zurück

void

getProjectFieldAsync(fieldId, callback)

Nur Projektdokumente. Projektfeld abrufen (z. B. ProjectWebAccessURL).

getProjectFieldAsync(fieldId: number, callback?: (result: AsyncResult<any>) => void): void;

Parameter

fieldId: number

Felder auf Projektebene.

callback: (result: Office.AsyncResult<any>) => void

Gibt zurück

void

Beispiele

// The following code example gets the values of three specified fields for the active project, 
// and then displays the values in the add-in.
// The example calls getProjectFieldAsync recursively, after the previous call returns successfully.
// It also tracks the calls to determine when all calls are sent.
// The example assumes your add-in has a reference to the jQuery library and that the 
// following page control is defined in the content div in the page body:
// <span id="message"></span>

(function () {
    "use strict";

    // The initialize function must be run each time a new page is loaded.
    Office.initialize = function (reason) {
        $(document).ready(function () {

            // Get information for the active project.
            getProjectInformation();
        });
    };

    // Get the specified fields for the active project.
    function getProjectInformation() {
        const fields =
            [Office.ProjectProjectFields.Start, 
             Office.ProjectProjectFields.Finish, 
             Office.ProjectProjectFields.GUID];
        const fieldValues = ['Start: ', 'Finish: ', 'GUID: '];
        let index = 0; 
        getField();

        // Get each field, and then display the field values in the add-in.
        function getField() {
            if (index == fields.length) {
                let output = '';
                for (let i = 0; i < fieldValues.length; i++) {
                    output += fieldValues[i] + '<br />';
                }
                $('#message').html(output);
            }
            else {
                Office.context.document.getProjectFieldAsync(
                    fields[index],
                    function (result) {

                        // If the call is successful, get the field value and then get the next field.
                        if (result.status === Office.AsyncResultStatus.Succeeded) {
                            fieldValues[index] += result.value.fieldValue;
                            getField(index++);
                        }
                        else {
                            onError(result.error);
                        }
                    }
                );
            }
        }
    }

    function onError(error) {
        $('#message').html(error.name + ' ' + error.code + ': ' + error.message);
    }
})();

getResourceByIndexAsync(resourceIndex, options, callback)

Nur Projektdokumente. Rufen Sie die GUID der Ressource ab, die den angegebenen Index in der Ressourcenauflistung aufweist.

Wichtig: Diese API funktioniert nur in Project 2016 auf Dem Windows-Desktop.

getResourceByIndexAsync(resourceIndex: number, options?: Office.AsyncContextOptions, callback?: (result: AsyncResult<string>) => void): void;

Parameter

resourceIndex: number

Der Index der Ressource in der Sammlung von Ressourcen für das Projekt.

options: Office.AsyncContextOptions

Bietet eine Option zum Beibehalten von Kontextdaten eines beliebigen Typs , unverändert, für die Verwendung in einem Rückruf.

callback: (result: Office.AsyncResult<string>) => void

Gibt zurück

void

getResourceByIndexAsync(resourceIndex, callback)

Nur Projektdokumente. Rufen Sie die GUID der Ressource ab, die den angegebenen Index in der Ressourcenauflistung aufweist.

Wichtig: Diese API funktioniert nur in Project 2016 auf Dem Windows-Desktop.

getResourceByIndexAsync(resourceIndex: number, callback?: (result: AsyncResult<string>) => void): void;

Parameter

resourceIndex: number

Der Index der Ressource in der Sammlung von Ressourcen für das Projekt.

callback: (result: Office.AsyncResult<string>) => void

Gibt zurück

void

Beispiele

// The following code example calls getMaxResourceIndexAsync to get the maximum index in the project's resource
// collection, and then calls getResourceByIndexAsync to get the GUID for each resource.
// The example assumes that your add-in has a reference to the jQuery library and that the following 
// page controls are defined in the content div in the page body:
// <input id="get-info" type="button" value="Get info" /><br />
// <span id="message"></span>

(function () {
    "use strict";
    const resourceGuids = [];

    // The initialize function must be run each time a new page is loaded.
    Office.initialize = function (reason) {
        $(document).ready(function () {

            // After the DOM is loaded, add-in-specific code can run.
            app.initialize();
            $('#get-info').on("click", getResourceInfo);
        });
    };

    // Get the maximum resource index, and then get the resource GUIDs.
    function getResourceInfo() {
        getMaxResourceIndex().then(
            function (data) {
                getResourceGuids(data);
            }
        );
    }

    // Get the maximum index of the resources for the current project.
    function getMaxResourceIndex() {
        const defer = $.Deferred();
        Office.context.document.getMaxResourceIndexAsync(
            function (result) {
                if (result.status === Office.AsyncResultStatus.Failed) {
                    onError(result.error);
                }
                else {
                    defer.resolve(result.value);
                }
            }
        );
        return defer.promise();
    }

    // Get each resource GUID, and then display the GUIDs in the add-in.
    // There is no 0 index for resources, so start with index 1.
    function getResourceGuids(maxResourceIndex) {
        const defer = $.Deferred();
        for (let i = 1; i <= maxResourceIndex; i++) {
            getResourceGuid(i);
        }
        return defer.promise();
        function getResourceGuid(index) {
            Office.context.document.getResourceByIndexAsync(index,
                function (result) {
                    if (result.status === Office.AsyncResultStatus.Succeeded) {
                        resourceGuids.push(result.value);
                        if (index == maxResourceIndex) {
                            defer.resolve();
                            $('#message').html(resourceGuids.toString());
                        }
                    }
                    else {
                        onError(result.error);
                    }
                }
            );
        }
    }
    function onError(error) {
        app.showNotification(error.name + ' ' + error.code + ': ' + error.message);
    }
})();

getResourceFieldAsync(resourceId, fieldId, options, callback)

Nur Projektdokumente. Abrufen des Ressourcenfelds für die angegebene Ressourcen-ID. (z. B. ResourceName)

getResourceFieldAsync(resourceId: string, fieldId: number, options?: Office.AsyncContextOptions, callback?: (result: AsyncResult<string>) => void): void;

Parameter

resourceId: string

Entweder eine Zeichenfolge oder ein Wert der Ressourcen-ID.

fieldId: number

Ressourcenfelder.

options: Office.AsyncContextOptions

Bietet eine Option zum Beibehalten von Kontextdaten eines beliebigen Typs , unverändert, für die Verwendung in einem Rückruf.

callback: (result: Office.AsyncResult<string>) => void

Gibt zurück

void

getResourceFieldAsync(resourceId, fieldId, callback)

Nur Projektdokumente. Abrufen des Ressourcenfelds für die angegebene Ressourcen-ID. (z. B. ResourceName)

getResourceFieldAsync(resourceId: string, fieldId: number, callback?: (result: AsyncResult<string>) => void): void;

Parameter

resourceId: string

Entweder eine Zeichenfolge oder ein Wert der Ressourcen-ID.

fieldId: number

Ressourcenfelder.

callback: (result: Office.AsyncResult<string>) => void

Gibt zurück

void

Beispiele

// The following code example calls getSelectedResourceAsync to get the GUID of the resource
// that's currently selected in a resource view. Then it gets three resource field values by calling 
// getResourceFieldAsync recursively.
// The example assumes your add-in has a reference to the jQuery library and that the following 
// page controls are defined in the content div in the page body:
// <input id="get-info" type="button" value="Get info" /><br />
// <span id="message"></span>

(function () {
    "use strict";

    // The initialize function must be run each time a new page is loaded.
    Office.initialize = function (reason) {
        $(document).ready(function () {

            // After the DOM is loaded, add-in-specific code can run.
            $('#get-info').on("click", getResourceInfo);
        });
    };

    // Get the GUID of the resource and then get the resource fields.
    function getResourceInfo() {
        getResourceGuid().then(
            function (data) {
                getResourceFields(data);
            }
        );
    }

    // Get the GUID of the selected resource.
    function getResourceGuid() {
        const defer = $.Deferred();
        Office.context.document.getSelectedResourceAsync(
            function (result) {
                if (result.status === Office.AsyncResultStatus.Failed) {
                    onError(result.error);
                }
                else {
                    defer.resolve(result.value);
                }
            }
        );
        return defer.promise();
    }

    // Get the specified fields for the selected resource.
    function getResourceFields(resourceGuid) {
        const targetFields =
            [Office.ProjectResourceFields.Name,
             Office.ProjectResourceFields.Units, 
             Office.ProjectResourceFields.BaseCalendar];
        const fieldValues = ['Name: ', 'Units: ', 'Base calendar: '];
        let index = 0; 
        getField();

        // Get each field, and then display the field values in the add-in.
        function getField() {
            if (index == targetFields.length) {
                let output = '';
                for (let i = 0; i < fieldValues.length; i++) {
                    output += fieldValues[i] + '<br />';
                }
                $('#message').html(output);
            }

            // If the call is successful, get the field value and then get the next field.
            else {
                Office.context.document.getResourceFieldAsync(
                    resourceGuid,
                    targetFields[index],
                    function (result) {
                        if (result.status === Office.AsyncResultStatus.Succeeded) {
                            fieldValues[index] += result.value.fieldValue;
                            getField(index++);
                        }
                        else {
                            onError(result.error);
                        }
                    }
                );
            }
        }
    }

    function onError(error) {
        $('#message').html(error.name + ' ' + error.code + ': ' + error.message);
    }
})();

getSelectedDataAsync(coercionType, options, callback)

Liest die Daten, die in der aktuellen Auswahl des Dokuments enthalten sind.

getSelectedDataAsync<T>(coercionType: Office.CoercionType, options?: GetSelectedDataOptions, callback?: (result: AsyncResult<T>) => void): void;

Parameter

coercionType: Office.CoercionType

Der Typ der Datenstruktur, die zurückgegeben werden soll. Informationen zu den unterstützten Koersionstypen jeder Anwendung finden Sie im Abschnitt Hinweise.

options: Office.GetSelectedDataOptions

Bietet Optionen zum Anpassen, welche Daten zurückgegeben und wie sie formatiert werden.

callback: (result: Office.AsyncResult<T>) => void

Optional. Eine Funktion, die aufgerufen wird, wenn der Rückruf zurückgibt, deren einziger Parameter vom Typ Office.AsyncResult ist. Die value -Eigenschaft des Ergebnisses sind die Daten in der aktuellen Auswahl. Dies wird in der Datenstruktur oder dem Format zurückgegeben, die Sie mit dem coercionType-Parameter angegeben haben. (Weitere Informationen zur Datenumwandlung finden unter Hinweise.)

Gibt zurück

void

Hinweise

Anforderungssätze:

HtmlCoercion (bei Verwendung von Office.CoercionType.Html)
MatrixCoercion (bei Verwendung von Office.CoercionType.Matrix)
OoxmlCoercion (bei Verwendung von Office.CoercionType.Ooxml)
Selection
TableCoercion (bei Verwendung von Office.CoercionType.Table)
TextCoercion (bei Verwendung von Office.CoercionType.Text)

In der Rückruffunktion, die an die getSelectedDataAsync-Methode übergeben wird, können Sie die Eigenschaften des AsyncResult-Objekts verwenden, um die folgenden Informationen zurückzugeben.

Eigenschaft	Verwendung
`AsyncResult.value`	Gibt immer zurück `undefined` , da kein Objekt oder keine Daten zum Abrufen vorhanden sind.
`AsyncResult.status`	Bestimmen des Erfolgs oder Fehlers des Vorgangs
`AsyncResult.error`	Zugreifen auf ein Error-Objekt, das Fehlerinformationen bereitstellt, wenn der Vorgang fehlgeschlagen ist
`AsyncResult.asyncContext`	Definieren eines Elements eines beliebigen Typs, der im AsyncResult-Objekt zurückgegeben wird, ohne geändert zu werden

Die möglichen Werte für den Office.CoercionType-Parameter variieren je nach Office-Anwendung.

`CoercionType`	Unterstützte Anwendungen
`Office.CoercionType.Html`	– Word
`Office.CoercionType.Matrix` (Array von Arrays)	-Excel – Word
`Office.CoercionType.Ooxml` (Office Open XML)	– Word
`Office.CoercionType.SlideRange`	-Powerpoint
`Office.CoercionType.Table` (TableData-Objekt)	-Excel – Word
`Office.CoercionType.Text` (Zeichenfolge)	-Excel -Powerpoint -Projekt – Word
`Office.CoercionType.XmlSvg`	– Excel unter Windows und auf Mac – PowerPoint unter Windows, auf Mac und im Web

Beispiele

// The following example uses the getSelectedDataAsync method of the Document object to retrieve the
// user's current selection as text, and then display it in the add-in's page.

// Displays the user's current selection.
function showSelection() {
    Office.context.document.getSelectedDataAsync(
        Office.CoercionType.Text,
        {
            valueFormat: Office.ValueFormat.Unformatted,
            filterType: Office.FilterType.All
        },
        (result) => {
            const dataValue = result.value;
            write('Selected data is: ' + dataValue);
        }
    );
}
// Function that writes to a div with id='message' on the page.
function write(message){
    document.getElementById('message').innerText += message; 
}

// To read the value of the current selection, you need to write a callback function that reads the selection.
// The following example shows how to:
// 1. Pass an anonymous callback function that reads the value of the current selection
//    to the callback parameter of the getSelectedDataAsync method.
// 2. Read the selection as text, unformatted, and not filtered.
// 3. Display the value on the add-in's page.
function getText() {
    Office.context.document.getSelectedDataAsync(
        Office.CoercionType.Text,
        {
            valueFormat: Office.ValueFormat.Unformatted,
            filterType: Office.FilterType.All
        },
        (asyncResult) => {
            const error = asyncResult.error;
            if (asyncResult.status === Office.AsyncResultStatus.Failed) {
                write(error.name + ": " + error.message);
            } 
            else {
                // Get selected data.
                const dataValue = asyncResult.value; 
                write('Selected data is ' + dataValue);
            }
        }
    );
}

// Function that writes to a div with id='message' on the page.
function write(message){
    document.getElementById('message').innerText += message; 
}

// The following code example gets the values of the selected cells. It uses the optional
// asyncContext parameter to pass some text to the callback function.
// The example assumes your add-in has a reference to the jQuery library and that the
// following page controls are defined in the content div in the page body:
// <input id="get-info" type="button" value="Get info" /><br />
// <span id="message"></span>

// The onReady function must be run each time a new page is loaded.
Office.onReady(() => {
    $(document).ready(() => {
        // After the DOM is loaded, add-in-specific code can run.
        $('#get-info').on("click", getSelectedText);
    });
});

// Gets the text from the selected cells in the document, and displays it in the add-in.
function getSelectedText() {
    Office.context.document.getSelectedDataAsync(
        Office.CoercionType.Text,
        { asyncContext: "Some related info" },
        (result) => {
            if (result.status === Office.AsyncResultStatus.Failed) {
                onError(result.error);
            }
            else {
                const output = String.format(
                    'Selected text: {0}<br/>Passed info: {1}',
                    result.value, result.asyncContext);
                $('#message').html(output);
            }
        }
    );
}

function onError(error) {
    $('#message').html(error.name + ' ' + error.code + ': ' + error.message);
}

getSelectedDataAsync(coercionType, callback)

Liest die Daten, die in der aktuellen Auswahl des Dokuments enthalten sind.

getSelectedDataAsync<T>(coercionType: Office.CoercionType, callback?: (result: AsyncResult<T>) => void): void;

Parameter

coercionType: Office.CoercionType

Der Typ der Datenstruktur, die zurückgegeben werden soll. Informationen zu den unterstützten Koersionstypen jeder Anwendung finden Sie im Abschnitt Hinweise.

callback: (result: Office.AsyncResult<T>) => void

Optional. Eine Funktion, die aufgerufen wird, wenn der Rückruf zurückgibt, deren einziger Parameter vom Typ Office.AsyncResult ist. Die value -Eigenschaft des Ergebnisses sind die Daten in der aktuellen Auswahl. Dies wird in der Datenstruktur oder dem Format zurückgegeben, die Sie mit dem coercionType-Parameter angegeben haben. (Weitere Informationen zur Datenumwandlung finden unter Hinweise.)

Gibt zurück

void

Hinweise

Anforderungssätze:

HtmlCoercion (bei Verwendung von Office.CoercionType.Html)
MatrixCoercion (bei Verwendung von Office.CoercionType.Matrix)
OoxmlCoercion (bei Verwendung von Office.CoercionType.Ooxml)
Selection
TableCoercion (bei Verwendung von Office.CoercionType.Table)
TextCoercion (bei Verwendung von Office.CoercionType.Text)

In der Rückruffunktion, die an die getSelectedDataAsync-Methode übergeben wird, können Sie die Eigenschaften des AsyncResult-Objekts verwenden, um die folgenden Informationen zurückzugeben.

Eigenschaft	Verwendung
`AsyncResult.value`	Gibt immer zurück `undefined` , da kein Objekt oder keine Daten zum Abrufen vorhanden sind.
`AsyncResult.status`	Bestimmen des Erfolgs oder Fehlers des Vorgangs
`AsyncResult.error`	Zugreifen auf ein Error-Objekt, das Fehlerinformationen bereitstellt, wenn der Vorgang fehlgeschlagen ist
`AsyncResult.asyncContext`	Definieren eines Elements eines beliebigen Typs, der im AsyncResult-Objekt zurückgegeben wird, ohne geändert zu werden

Die möglichen Werte für den Office.CoercionType-Parameter variieren je nach Office-Anwendung.

`CoercionType`	Unterstützte Anwendungen
`Office.CoercionType.Html`	– Word
`Office.CoercionType.Matrix` (Array von Arrays)	-Excel – Word
`Office.CoercionType.Ooxml` (Office Open XML)	– Word
`Office.CoercionType.SlideRange`	-Powerpoint
`Office.CoercionType.Table` (TableData-Objekt)	-Excel – Word
`Office.CoercionType.Text` (Zeichenfolge)	-Excel -Powerpoint -Projekt – Word
`Office.CoercionType.XmlSvg`	– Excel unter Windows und auf Mac – PowerPoint unter Windows, auf Mac und im Web

getSelectedResourceAsync(options, callback)

Nur Projektdokumente. Ruft die ID der aktuell ausgewählten Ressource ab.

getSelectedResourceAsync(options?: Office.AsyncContextOptions, callback?: (result: AsyncResult<string>) => void): void;

Parameter

options: Office.AsyncContextOptions

Bietet eine Option zum Beibehalten von Kontextdaten eines beliebigen Typs , unverändert, für die Verwendung in einem Rückruf.

callback: (result: Office.AsyncResult<string>) => void

Gibt zurück

void

getSelectedResourceAsync(callback)

Nur Projektdokumente. Ruft die ID der aktuell ausgewählten Ressource ab.

getSelectedResourceAsync(callback?: (result: AsyncResult<string>) => void): void;

Parameter

callback: (result: Office.AsyncResult<string>) => void

Gibt zurück

void

Beispiele

// The following code example calls getSelectedResourceAsync to get the GUID of the resource that's 
// currently selected in a resource view. Then it gets three resource field values by calling 
// getResourceFieldAsync recursively.
// The example assumes your add-in has a reference to the jQuery library and that the following page controls are
// defined in the content div in the page body:
// <input id="get-info" type="button" value="Get info" /><br />
// <span id="message"></span>

(function () {
    "use strict";

    // The initialize function must be run each time a new page is loaded.
    Office.initialize = function (reason) {
        $(document).ready(function () {

            // After the DOM is loaded, add-in-specific code can run.
            $('#get-info').on("click", getResourceInfo);
        });
    };

    // Get the GUID of the resource and then get the resource fields.
    function getResourceInfo() {
        getResourceGuid().then(
            function (data) {
                getResourceFields(data);
            }
        );
    }

    // Get the GUID of the selected resource.
    function getResourceGuid() {
        const defer = $.Deferred();
        Office.context.document.getSelectedResourceAsync(
            function (result) {
                if (result.status === Office.AsyncResultStatus.Failed) {
                    onError(result.error);
                }
                else {
                    defer.resolve(result.value);
                }
            }
        );
        return defer.promise();
    }

    // Get the specified fields for the selected resource.
    function getResourceFields(resourceGuid) {
        const targetFields =
            [Office.ProjectResourceFields.Name,
             Office.ProjectResourceFields.Units, 
             Office.ProjectResourceFields.BaseCalendar];
        const fieldValues = ['Name: ', 'Units: ', 'Base calendar: '];
        let index = 0; 
        getField();

        // Get each field, and then display the field values in the add-in.
        function getField() {
            if (index == targetFields.length) {
                let output = '';
                for (let i = 0; i < fieldValues.length; i++) {
                    output += fieldValues[i] + '<br />';
                }
                $('#message').html(output);
            }

            // If the call is successful, get the field value and then get the next field.
            else {
                Office.context.document.getResourceFieldAsync(
                    resourceGuid,
                    targetFields[index],
                    function (result) {
                        if (result.status === Office.AsyncResultStatus.Succeeded) {
                            fieldValues[index] += result.value.fieldValue;
                            getField(index++);
                        }
                        else {
                            onError(result.error);
                        }
                    }
                );
            }
        }
    }

    function onError(error) {
        $('#message').html(error.name + ' ' + error.code + ': ' + error.message);
    }
})();

getSelectedTaskAsync(options, callback)

Nur Projektdokumente. Ruft die ID der aktuell ausgewählten Aufgabe ab.

getSelectedTaskAsync(options?: Office.AsyncContextOptions, callback?: (result: AsyncResult<string>) => void): void;

Parameter

options: Office.AsyncContextOptions

Bietet eine Option zum Beibehalten von Kontextdaten eines beliebigen Typs , unverändert, für die Verwendung in einem Rückruf.

callback: (result: Office.AsyncResult<string>) => void

Gibt zurück

void

getSelectedTaskAsync(callback)

Nur Projektdokumente. Ruft die ID der aktuell ausgewählten Aufgabe ab.

getSelectedTaskAsync(callback?: (result: AsyncResult<string>) => void): void;

Parameter

callback: (result: Office.AsyncResult<string>) => void

Gibt zurück

void

Beispiele

// The following code example calls getSelectedTaskAsync to get the GUID of the task that's currently
// selected in a task view. Then it gets task properties by calling getTaskAsync.
// The example assumes your add-in has a reference to the jQuery library and that the following page
// controls are defined in the content div in the page body:
// <input id="get-info" type="button" value="Get info" /><br />
// <span id="message"></span>

(function () {
    "use strict";

    // The initialize function must be run each time a new page is loaded.
    Office.initialize = function (reason) {
        $(document).ready(function () {

            // After the DOM is loaded, add-in-specific code can run.
            $('#get-info').on("click", getTaskInfo);
        });
    };

    // // Get the GUID of the task, and then get local task properties.
    function getTaskInfo() {
        getTaskGuid().then(
            function (data) {
                getTaskProperties(data);
            }
        );
    }

    // Get the GUID of the selected task.
    function getTaskGuid() {
        const defer = $.Deferred();
        Office.context.document.getSelectedTaskAsync(
            function (result) {
                if (result.status === Office.AsyncResultStatus.Failed) {
                    onError(result.error);
                }
                else {
                    defer.resolve(result.value);
                }
            }
        );
        return defer.promise();
    }

    // Get local properties for the selected task, and then display it in the add-in.
    function getTaskProperties(taskGuid) {
        Office.context.document.getTaskAsync(
            taskGuid,
            function (result) {
                if (result.status === Office.AsyncResultStatus.Failed) {
                    onError(result.error);
                }
                else {
                    const taskInfo = result.value;
                    const output = String.format(
                        'Name: {0}<br/>GUID: {1}<br/>SharePoint task ID: {2}<br/>Resource names: {3}',
                        taskInfo.taskName, taskGuid, taskInfo.wssTaskId, taskInfo.resourceNames);
                    $('#message').html(output);
                }
            }
        );
    }

    function onError(error) {
        $('#message').html(error.name + ' ' + error.code + ': ' + error.message);
    }
})();

getSelectedViewAsync(options, callback)

Nur Projektdokumente. Rufen Sie den aktuell ausgewählten Ansichtstyp (z. B. Gantt) und ansichtsnamen ab.

getSelectedViewAsync(options?: Office.AsyncContextOptions, callback?: (result: AsyncResult<any>) => void): void;

Parameter

options: Office.AsyncContextOptions

Bietet eine Option zum Beibehalten von Kontextdaten eines beliebigen Typs , unverändert, für die Verwendung in einem Rückruf.

callback: (result: Office.AsyncResult<any>) => void

Optional. Eine Funktion, die aufgerufen wird, wenn der Rückruf zurückgibt, deren einziger Parameter vom Typ Office.AsyncResult ist. Die value -Eigenschaft des Ergebnisses enthält die folgenden Eigenschaften: viewName - Der Name der Ansicht als ProjectViewTypes-Konstante. viewType – Der Ansichtstyp als ganzzahliger Wert einer ProjectViewTypes-Konstante.

Gibt zurück

void

getSelectedViewAsync(callback)

Nur Projektdokumente. Rufen Sie den aktuell ausgewählten Ansichtstyp (z. B. Gantt) und ansichtsnamen ab.

getSelectedViewAsync(callback?: (result: AsyncResult<any>) => void): void;

Parameter

callback: (result: Office.AsyncResult<any>) => void

Optional. Eine Funktion, die aufgerufen wird, wenn der Rückruf zurückgibt, deren einziger Parameter vom Typ Office.AsyncResult ist. Die value -Eigenschaft des Ergebnisses enthält die folgenden Eigenschaften: viewName - Der Name der Ansicht als ProjectViewTypes-Konstante. viewType – Der Ansichtstyp als ganzzahliger Wert einer ProjectViewTypes-Konstante.

Gibt zurück

void

Beispiele

// The following code example calls adds a ViewSelectionChanged event handler that
// calls getSelectedViewAsync to get the name and type of the active view in the document.
// The example assumes your add-in has a reference to the jQuery library and that
// the following page control is defined in the content div in the page body:
// <span id="message"></span>

(function () {
    "use strict";

    // The initialize function must be run each time a new page is loaded.
    Office.initialize = function (reason) {
        $(document).ready(function () {

            // After the DOM is loaded, add-in-specific code can run.
            Office.context.document.addHandlerAsync(
                Office.EventType.ViewSelectionChanged,
                getActiveView);
            getActiveView();
        });
    };

    // Get the active view's name and type.
    function getActiveView() {
        Office.context.document.getSelectedViewAsync(
            function (result) {
                if (result.status === Office.AsyncResultStatus.Failed) {
                    onError(result.error);
                }
                else {
                    const output = String.format(
                        'View name: {0}<br/>View type: {1}',
                        result.value.viewName, viewType);
                    $('#message').html(output);
                }
            }
        );
    }

    function onError(error) {
        $('#message').html(error.name + ' ' + error.code + ': ' + error.message);
    }
})();

getTaskAsync(taskId, options, callback)

Nur Projektdokumente. Rufen Sie den Vorgangsnamen, die WSS-Vorgangs-ID und die Ressourcennamen für die angegebene taskId ab.

getTaskAsync(taskId: string, options?: Office.AsyncContextOptions, callback?: (result: AsyncResult<any>) => void): void;

Parameter

taskId: string

Entweder eine Zeichenfolge oder ein Wert der Aufgaben-ID.

options: Office.AsyncContextOptions

Bietet eine Option zum Beibehalten von Kontextdaten eines beliebigen Typs , unverändert, für die Verwendung in einem Rückruf.

callback: (result: Office.AsyncResult<any>) => void

Optional. Eine Funktion, die aufgerufen wird, wenn der Rückruf zurückgibt, deren einziger Parameter vom Typ Office.AsyncResult ist. Die value -Eigenschaft des Ergebnisses enthält die folgenden Eigenschaften: taskName - Der Name der Aufgabe. wssTaskId : Die ID der Aufgabe in der synchronisierten SharePoint-Aufgabenliste. Wenn das Projekt nicht mit einer SharePoint-Aufgabenliste synchronisiert wird, ist der Wert 0. resourceNames – Die durch Trennzeichen getrennte Liste der Namen der Ressourcen, die dem Vorgang zugewiesen sind.

Gibt zurück

void

getTaskAsync(taskId, callback)

Nur Projektdokumente. Rufen Sie den Vorgangsnamen, die WSS-Vorgangs-ID und die Ressourcennamen für die angegebene taskId ab.

getTaskAsync(taskId: string, callback?: (result: AsyncResult<any>) => void): void;

Parameter

taskId: string

Entweder eine Zeichenfolge oder ein Wert der Aufgaben-ID.

callback: (result: Office.AsyncResult<any>) => void

Optional. Eine Funktion, die aufgerufen wird, wenn der Rückruf zurückgibt, deren einziger Parameter vom Typ Office.AsyncResult ist. Die value -Eigenschaft des Ergebnisses enthält die folgenden Eigenschaften: taskName - Der Name der Aufgabe. wssTaskId : Die ID der Aufgabe in der synchronisierten SharePoint-Aufgabenliste. Wenn das Projekt nicht mit einer SharePoint-Aufgabenliste synchronisiert wird, ist der Wert 0. resourceNames – Die durch Trennzeichen getrennte Liste der Namen der Ressourcen, die dem Vorgang zugewiesen sind.

Gibt zurück

void

Beispiele

// The following code example calls getSelectedTaskAsync to get the task GUID of the currently
// selected task. Then it calls getTaskAsync to get the properties for the task that are
// available from the JavaScript API for Office.
// The example assumes your add-in has a reference to the jQuery library and that the
// following page controls are defined in the content div in the page body:
// <input id="get-info" type="button" value="Get info" /><br />
// <span id="message"></span>

(function () {
    "use strict";

    // The initialize function must be run each time a new page is loaded.
    Office.initialize = function (reason) {
        $(document).ready(function () {

            // After the DOM is loaded, add-in-specific code can run.
            $('#get-info').on("click", getTaskInfo);
        });
    };

    // Get the GUID of the task, and then get local task properties.
    function getTaskInfo() {
        getTaskGuid().then(
            function (data) {
                getTaskProperties(data);
            }
        );
    }

    // Get the GUID of the selected task.
    function getTaskGuid() {
        const defer = $.Deferred();
        Office.context.document.getSelectedTaskAsync(
            function (result) {
                if (result.status === Office.AsyncResultStatus.Failed) {
                    onError(result.error);
                }
                else {
                    defer.resolve(result.value);
                }
            }
        );
        return defer.promise();
    }

    // Get local properties for the selected task, and then display it in the add-in.
    function getTaskProperties(taskGuid) {
        Office.context.document.getTaskAsync(
            taskGuid,
            function (result) {
                if (result.status === Office.AsyncResultStatus.Failed) {
                    onError(result.error);
                }
                else {
                    const taskInfo = result.value;
                    const output = String.format(
                        'Name: {0}<br/>GUID: {1}<br/>SharePoint task ID: {2}<br/>Resource names: {3}',
                        taskInfo.taskName, taskGuid, taskInfo.wssTaskId, taskInfo.resourceNames);
                    $('#message').html(output);
                }
            }
        );
    }

    function onError(error) {
        $('#message').html(error.name + ' ' + error.code + ': ' + error.message);
    }
})();

getTaskByIndexAsync(taskIndex, options, callback)

Nur Projektdokumente. Ruft die GUID des Tasks ab, der den angegebenen Index in der Aufgabenauflistung aufweist.

Wichtig: Diese API funktioniert nur in Project 2016 auf Dem Windows-Desktop.

getTaskByIndexAsync(taskIndex: number, options?: Office.AsyncContextOptions, callback?: (result: AsyncResult<string>) => void): void;

Parameter

taskIndex: number

Der Index der Aufgabe in der Sammlung von Aufgaben für das Projekt.

options: Office.AsyncContextOptions

Bietet eine Option zum Beibehalten von Kontextdaten eines beliebigen Typs , unverändert, für die Verwendung in einem Rückruf.

callback: (result: Office.AsyncResult<string>) => void

Gibt zurück

void

getTaskByIndexAsync(taskIndex, callback)

Nur Projektdokumente. Ruft die GUID des Tasks ab, der den angegebenen Index in der Aufgabenauflistung aufweist.

Wichtig: Diese API funktioniert nur in Project 2016 auf Dem Windows-Desktop.

getTaskByIndexAsync(taskIndex: number, callback?: (result: AsyncResult<string>) => void): void;

Parameter

taskIndex: number

Der Index der Aufgabe in der Sammlung von Aufgaben für das Projekt.

callback: (result: Office.AsyncResult<string>) => void

Gibt zurück

void

Beispiele

// The following code example calls getMaxTaskIndexAsync to get the
// maximum index in the project's task collection, and then
// calls getTaskByIndexAsync to get the GUID for each task.
// The example assumes that your add-in has a reference to the
// jQuery library and that the following page controls are defined
// in the content div in the page body:
// <input id="get-info" type="button" value="Get info" /><br />
// <span id="message"></span>

(function () {
    "use strict";
    const taskGuids = [];

    // The initialize function must be run each time a new page is loaded.
    Office.initialize = function (reason) {
        $(document).ready(function () {

            // After the DOM is loaded, add-in-specific code can run.
            app.initialize();
            $('#get-info').on("click", getTaskInfo);
        });
    };

    // Get the maximum task index, and then get the task GUIDs.
    function getTaskInfo() {
        getMaxTaskIndex().then(
            function (data) {
                getTaskGuids(data);
            }
        );
    }

    // Get the maximum index of the tasks for the current project.
    function getMaxTaskIndex() {
        const defer = $.Deferred();
        Office.context.document.getMaxTaskIndexAsync(
            function (result) {
                if (result.status === Office.AsyncResultStatus.Failed) {
                    onError(result.error);
                }
                else {
                    defer.resolve(result.value);
                }
            }
        );
        return defer.promise();
    }

    // Get each task GUID, and then display the GUIDs in the add-in.
    function getTaskGuids(maxTaskIndex) {
        const defer = $.Deferred();
        for (let i = 0; i <= maxTaskIndex; i++) {
            getTaskGuid(i);
        }
        return defer.promise();
        function getTaskGuid(index) {
            Office.context.document.getTaskByIndexAsync(index,
                function (result) {
                    if (result.status === Office.AsyncResultStatus.Succeeded) {
                        taskGuids.push(result.value);
                        if (index == maxTaskIndex) {
                            defer.resolve();
                            $('#message').html(taskGuids.toString());
                        }
                    }
                    else {
                        onError(result.error);
                    }
                }
            );
        }
    }
    function onError(error) {
        app.showNotification(error.name + ' ' + error.code + ': ' + error.message);
    }
})();

getTaskFieldAsync(taskId, fieldId, options, callback)

Nur Projektdokumente. Dient zum Abrufen des Vorgangsfelds für die angegebene Vorgangs-ID. (z. B. StartDate).

getTaskFieldAsync(taskId: string, fieldId: number, options?: Office.AsyncContextOptions, callback?: (result: AsyncResult<any>) => void): void;

Parameter

taskId: string

Entweder eine Zeichenfolge oder ein Wert der Aufgaben-ID.

fieldId: number

Aufgabenfelder.

options: Office.AsyncContextOptions

Bietet eine Option zum Beibehalten von Kontextdaten eines beliebigen Typs , unverändert, für die Verwendung in einem Rückruf.

callback: (result: Office.AsyncResult<any>) => void

Gibt zurück

void

getTaskFieldAsync(taskId, fieldId, callback)

Nur Projektdokumente. Dient zum Abrufen des Vorgangsfelds für die angegebene Vorgangs-ID. (z. B. StartDate).

getTaskFieldAsync(taskId: string, fieldId: number, callback?: (result: AsyncResult<any>) => void): void;

Parameter

taskId: string

Entweder eine Zeichenfolge oder ein Wert der Aufgaben-ID.

fieldId: number

Aufgabenfelder.

callback: (result: Office.AsyncResult<any>) => void

Gibt zurück

void

Beispiele

// The following code example calls getSelectedTaskAsync to get the GUID of the task that's currently
// selected in a task view. Then it gets two task field values by calling getTaskFieldAsync recursively.
// The example assumes your add-in has a reference to the jQuery library and that the following page
// controls are defined in the content div in the page body:
// <input id="get-info" type="button" value="Get info" /><br />
// <span id="message"></span>

(function () {
    "use strict";

    // The initialize function must be run each time a new page is loaded.
    Office.initialize = function (reason) {
        $(document).ready(function () {
            
            // After the DOM is loaded, add-in-specific code can run.
            $('#get-info').on("click", getTaskInfo);
        });
    };

    // Get the GUID of the task, and then get the task fields.
    function getTaskInfo() {
        getTaskGuid().then(
            function (data) {
                getTaskFields(data);
            }
        );
    }

    // Get the GUID of the selected task.
    function getTaskGuid() {
        const defer = $.Deferred();
        Office.context.document.getSelectedTaskAsync(
            function (result) {
                if (result.status === Office.AsyncResultStatus.Failed) {
                    onError(result.error);
                }
                else {
                    defer.resolve(result.value);
                }
            }
        );
        return defer.promise();
    }

    // Get the specified fields for the selected task.
    function getTaskFields(taskGuid) {
        let output = '';
        const targetFields = [Office.ProjectTaskFields.Priority, Office.ProjectTaskFields.PercentComplete];
        const fieldValues = ['Priority: ', '% Complete: '];
        let index = 0;
        getField();

        // Get each field, and then display the field values in the add-in.
        function getField() {
            if (index == targetFields.length) {
                for (let i = 0; i < fieldValues.length; i++) {
                    output += fieldValues[i] + '<br />';
                }
                $('#message').html(output);
            }

            // Get the field value. If the call is successful, then get the next field.
            else {
                Office.context.document.getTaskFieldAsync(
                    taskGuid,
                    targetFields[index],
                    function (result) {
                        if (result.status === Office.AsyncResultStatus.Succeeded) {
                            fieldValues[index] += result.value.fieldValue;
                            getField(index++);
                        }
                        else {
                            onError(result.error);
                        }
                    }
                );
            }
        }
    }

    function onError(error) {
        $('#message').html(error.name + ' ' + error.code + ': ' + error.message);
    }
})();

getWSSUrlAsync(options, callback)

Nur Projektdokumente. Rufen Sie die WSS-URL und den Listennamen für die Aufgabenliste ab. Das MPP wird ebenfalls synchronisiert.

getWSSUrlAsync(options?: Office.AsyncContextOptions, callback?: (result: AsyncResult<any>) => void): void;

Parameter

options: Office.AsyncContextOptions

Bietet eine Option zum Beibehalten von Kontextdaten eines beliebigen Typs , unverändert, für die Verwendung in einem Rückruf.

callback: (result: Office.AsyncResult<any>) => void

Optional. Eine Funktion, die aufgerufen wird, wenn der Rückruf zurückgibt, deren einziger Parameter vom Typ Office.AsyncResult ist. Die value -Eigenschaft des Ergebnisses enthält die folgenden Eigenschaften: listName - der Name der synchronisierten SharePoint-Aufgabenliste. serverUrl : die URL der synchronisierten SharePoint-Aufgabenliste.

Gibt zurück

void

getWSSUrlAsync(callback)

Nur Projektdokumente. Rufen Sie die WSS-URL und den Listennamen für die Aufgabenliste ab. Das MPP wird ebenfalls synchronisiert.

getWSSUrlAsync(callback?: (result: AsyncResult<any>) => void): void;

Parameter

callback: (result: Office.AsyncResult<any>) => void

Optional. Eine Funktion, die aufgerufen wird, wenn der Rückruf zurückgibt, deren einziger Parameter vom Typ Office.AsyncResult ist. Die value -Eigenschaft des Ergebnisses enthält die folgenden Eigenschaften: listName - der Name der synchronisierten SharePoint-Aufgabenliste. serverUrl : die URL der synchronisierten SharePoint-Aufgabenliste.

Gibt zurück

void

goToByIdAsync(id, goToType, options, callback)

Wechselt zum angegebenen Objekt oder Speicherort im Dokument.

goToByIdAsync(id: string | number, goToType: GoToType, options?: GoToByIdOptions, callback?: (result: AsyncResult<any>) => void): void;

Parameter

id: string | number

Der Bezeichner des Objekts oder Speicherorts, zu dem gewechselt werden soll.

goToType: Office.GoToType

Der Typ des Speicherorts, zu dem gewechselt werden soll.

options: Office.GoToByIdOptions

Stellt Optionen bereit, die angeben, ob der Speicherort ausgewählt werden soll, zu dem navigiert wird.

callback: (result: Office.AsyncResult<any>) => void

Gibt zurück

void

Hinweise

Anforderungssatz: Nicht in einem Satz

PowerPoint unterstützt die goToByIdAsync-Methode in Masteransichten nicht.

Das durch die option selectionMode verursachte Verhalten variiert je nach Office-Anwendung:

In Excel: Office.SelectionMode.Selected Wählt den gesamten Inhalt in der Bindung oder das benannte Element aus. Office.SelectionMode.Nonewählt für Textbindungen die Zelle aus; für Matrixbindungen, Tabellenbindungen und benannte Elemente wird die erste Datenzelle (nicht die erste Zell in der Kopfzeile für Tabellen) ausgewählt.

In PowerPoint: Office.SelectionMode.Selected Wählt den Folientitel oder das erste Textfeld auf der Folie aus. Office.SelectionMode.None wählt nichts aus.

In Word: Office.SelectionMode.Selected Wählt den gesamten Inhalt in der Bindung aus. Office.SelectionMode.None verschiebt für Textbindungen den Cursor an den Anfang des Textes; für Matrixbindungen und Tabellenbindungen wird die erste Datenzelle (nicht die erste Zelle in der Kopfzeile für Tabellen) ausgewählt.

goToByIdAsync(id, goToType, callback)

Wechselt zum angegebenen Objekt oder Speicherort im Dokument.

goToByIdAsync(id: string | number, goToType: GoToType, callback?: (result: AsyncResult<any>) => void): void;

Parameter

id: string | number

Der Bezeichner des Objekts oder Speicherorts, zu dem gewechselt werden soll.

goToType: Office.GoToType

Der Typ des Speicherorts, zu dem gewechselt werden soll.

callback: (result: Office.AsyncResult<any>) => void

Gibt zurück

void

Hinweise

Anforderungssatz: Nicht in einem Satz

PowerPoint unterstützt die goToByIdAsync-Methode in Masteransichten nicht.

Das durch die option selectionMode verursachte Verhalten variiert je nach Office-Anwendung:

In PowerPoint: Office.SelectionMode.Selected Wählt den Folientitel oder das erste Textfeld auf der Folie aus. Office.SelectionMode.None wählt nichts aus.

Beispiele

// Go to a binding by id (Word and Excel)
// The following example shows how to:
// 1. Create a table binding using the addFromSelectionAsync method as a sample binding to work with.
// 2. Specify that binding as the binding to go to.
// 3. Pass an anonymous callback function that returns the status of the operation
//    to the callback parameter of the goToByIdAsync method.
// 4. Display the value on the add-in's page.
function gotoBinding() {
    // Create a new table binding for the selected table.
    Office.context.document.bindings.addFromSelectionAsync("table",{ id: "MyTableBinding" }, function (asyncResult) {
    if (asyncResult.status == "failed") {
              showMessage("Action failed with error: " + asyncResult.error.message);
          }
          else {
              showMessage("Added new binding with type: " + asyncResult.value.type +" and id: " + asyncResult.value.id);
          }
    });

    // Go to binding by id.
    Office.context.document.goToByIdAsync("MyTableBinding", Office.GoToType.Binding, function (asyncResult) {
        if (asyncResult.status == "failed") {
            showMessage("Action failed with error: " + asyncResult.error.message);
        }
        else {
            showMessage("Navigation successful");
        }
    });
}

// Go to a table in a spreadsheet (Excel)
// The following example shows how to:
// 1. Specify a table by name as the table to go to.
// 2. Pass an anonymous callback function that returns the status of the operation
//    to the callback parameter of the goToByIdAsync method.
// 3. Display the value on the add-in's page.
function goToTable() {
    Office.context.document.goToByIdAsync("Table1", Office.GoToType.NamedItem, function (asyncResult) {
        if (asyncResult.status == "failed") {
            showMessage("Action failed with error: " + asyncResult.error.message);
        }
        else {
            showMessage("Navigation successful");
        }
    });
}

// Go to the currently selected slide by id (PowerPoint)
// The following example shows how to:
// 1. Get the id of the currently selected slides using the getSelectedDataAsync method.
// 2. Specify the returned id as the slide to go to.
// 3. Pass an anonymous callback function that returns the status of the operation
//    to the callback parameter of the goToByIdAsync method.
// 4. Display the value of the stringified JSON object returned by asyncResult.value,
//    which contains information about the selected slides, on the add-in's page.
let firstSlideId = 0;
function gotoSelectedSlide() {
    //Get currently selected slide's id
    Office.context.document.getSelectedDataAsync(Office.CoercionType.SlideRange, function (asyncResult) {
        if (asyncResult.status == "failed") {
            app.showNotification("Action failed with error: " + asyncResult.error.message);
        }
        else {
            firstSlideId = asyncResult.value.slides[0].id;
            app.showNotification(JSON.stringify(asyncResult.value));
        }
    });
    //Go to slide by id.
    Office.context.document.goToByIdAsync(firstSlideId, Office.GoToType.Slide, function (asyncResult) {
        if (asyncResult.status == "failed") {
            app.showNotification("Action failed with error: " + asyncResult.error.message);
        }
        else {
            app.showNotification("Navigation successful");
        }
    });
}

// Go to slide by index (PowerPoint)
// The following example shows how to:
// 1. Specify the index of the first, last, previous, or next slide to go to.
// 2. Pass an anonymous callback function that returns the status of the operation
//    to the callback parameter of the goToByIdAsync method.
// 3. Display the value on the add-in's page.
function goToSlideByIndex() {
    const goToFirst = Office.Index.First;
    const goToLast = Office.Index.Last;
    const goToPrevious = Office.Index.Previous;
    const goToNext = Office.Index.Next;

    Office.context.document.goToByIdAsync(goToNext, Office.GoToType.Index, function (asyncResult) {
        if (asyncResult.status == "failed") {
            showMessage("Action failed with error: " + asyncResult.error.message);
        }
        else {
            showMessage("Navigation successful");
        }
    });
}

removeHandlerAsync(eventType, options, callback)

Entfernt einen Ereignishandler für den angegebenen Ereignistyp.

removeHandlerAsync(eventType: Office.EventType, options?: RemoveHandlerOptions, callback?: (result: AsyncResult<void>) => void): void;

Parameter

eventType: Office.EventType

Der Ereignistyp. Für dokument kann "Document.SelectionChanged" oder "Document.ActiveViewChanged" sein.

options: Office.RemoveHandlerOptions

Stellt Optionen bereit, um zu bestimmen, welche Ereignishandler oder Handler entfernt werden.

callback: (result: Office.AsyncResult<void>) => void

Optional. Eine Funktion, die aufgerufen wird, wenn der Rückruf zurückgibt, deren einziger Parameter vom Typ Office.AsyncResult ist.

Gibt zurück

void

Hinweise

Anforderungssatz: DocumentEvents

removeHandlerAsync(eventType, callback)

Entfernt einen Ereignishandler für den angegebenen Ereignistyp.

removeHandlerAsync(eventType: Office.EventType, callback?: (result: AsyncResult<void>) => void): void;

Parameter

eventType: Office.EventType

Der Ereignistyp. Für dokument kann "Document.SelectionChanged" oder "Document.ActiveViewChanged" sein.

callback: (result: Office.AsyncResult<void>) => void

Optional. Eine Funktion, die aufgerufen wird, wenn der Rückruf zurückgibt, deren einziger Parameter vom Typ Office.AsyncResult ist.

Gibt zurück

void

Hinweise

Anforderungssatz: DocumentEvents

Beispiele

// The following example removes the event handler named 'MyHandler'.
function removeSelectionChangedEventHandler() {
    Office.context.document.removeHandlerAsync(Office.EventType.DocumentSelectionChanged, {handler:MyHandler});
}

function MyHandler(eventArgs) {
    doSomethingWithDocument(eventArgs.document);
}

// The following code example uses addHandlerAsync to add an event handler for the
// ResourceSelectionChanged event and removeHandlerAsync to remove the handler.
// When a resource is selected in a resource view, the handler displays the
// resource GUID. When the handler is removed, the GUID is not displayed.
// The example assumes that your add-in has a reference to the jQuery library and
// that the following page control is defined in the content div in the page body:
// <input id="remove-handler" type="button" value="Remove handler" /><br />
// <span id="message"></span>

(function () {
    "use strict";

    // The initialize function must be run each time a new page is loaded.
    Office.initialize = function (reason) {
        $(document).ready(function () {

            // After the DOM is loaded, add-in-specific code can run.
            Office.context.document.addHandlerAsync(
                Office.EventType.ResourceSelectionChanged,
                getResourceGuid);
            $('#remove-handler').on("click", removeEventHandler);
        });
    };

    // Remove the event handler.
    function removeEventHandler() {
        Office.context.document.removeHandlerAsync(
            Office.EventType.ResourceSelectionChanged,
            {handler:getResourceGuid,
            asyncContext:'The handler is removed.'},
            function (result) {
                if (result.status === Office.AsyncResultStatus.Failed) {
                    onError(result.error);
                }
                else {
                    $('#remove-handler').attr('disabled', 'disabled');
                    $('#message').html(result.asyncContext);
                }
            }
        );
    }

    // Get the GUID of the currently selected resource and display it in the add-in.
    function getResourceGuid() {
        Office.context.document.getSelectedResourceAsync(
            function (result) {
                if (result.status === Office.AsyncResultStatus.Failed) {
                    onError(result.error);
                }
                else {
                    $('#message').html('Resource GUID: ' + result.value);
                }
            }
        );
    }

    function onError(error) {
        $('#message').html(error.name + ' ' + error.code + ': ' + error.message);
    }
})();

setResourceFieldAsync(resourceId, fieldId, fieldValue, options, callback)

Nur Projektdokumente. Legen Sie das Ressourcenfeld für die angegebene Ressourcen-ID fest.

Wichtig: Diese API funktioniert nur in Project 2016 auf Dem Windows-Desktop.

setResourceFieldAsync(resourceId: string, fieldId: number, fieldValue: string | number | boolean | object, options?: Office.AsyncContextOptions, callback?: (result: AsyncResult<void>) => void): void;

Parameter

resourceId: string

Entweder eine Zeichenfolge oder ein Wert der Ressourcen-ID.

fieldId: number

Ressourcenfelder.

fieldValue: string | number | boolean | object

Wert des Zielfelds.

options: Office.AsyncContextOptions

Bietet eine Option zum Beibehalten von Kontextdaten eines beliebigen Typs , unverändert, für die Verwendung in einem Rückruf.

callback: (result: Office.AsyncResult<void>) => void

Optional. Eine Funktion, die aufgerufen wird, wenn der Rückruf zurückgibt, deren einziger Parameter vom Typ Office.AsyncResult ist.

Gibt zurück

void

setResourceFieldAsync(resourceId, fieldId, fieldValue, callback)

Nur Projektdokumente. Legen Sie das Ressourcenfeld für die angegebene Ressourcen-ID fest.

Wichtig: Diese API funktioniert nur in Project 2016 auf Dem Windows-Desktop.

setResourceFieldAsync(resourceId: string, fieldId: number, fieldValue: string | number | boolean | object, callback?: (result: AsyncResult<void>) => void): void;

Parameter

resourceId: string

Entweder eine Zeichenfolge oder ein Wert der Ressourcen-ID.

fieldId: number

Ressourcenfelder.

fieldValue: string | number | boolean | object

Wert des Zielfelds.

callback: (result: Office.AsyncResult<void>) => void

Optional. Eine Funktion, die aufgerufen wird, wenn der Rückruf zurückgibt, deren einziger Parameter vom Typ Office.AsyncResult ist.

Gibt zurück

void

Beispiele

// The following code example calls getSelectedResourceAsync to get the GUID of the resource that's
// currently selected in a resource view. Then it sets two resource field values by calling
// setResourceFieldAsync recursively.
// The getSelectedTaskAsync method used in the example requires that a task view
// (for example, Task Usage) is the active view and that a task is selected. See the addHandlerAsync
// method for an example that activates a button based on the active view type.
// The example assumes your add-in has a reference to the jQuery library and that the
// following page controls are defined in the content div in the page body:
// <input id="set-info" type="button" value="Set info" /><br />
// <span id="message"></span>

(function () {
    "use strict";

    // The initialize function must be run each time a new page is loaded.
    Office.initialize = function (reason) {
        $(document).ready(function () {

            // After the DOM is loaded, add-in-specific code can run.
            app.initialize();
            $('#set-info').on("click", setResourceInfo);
        });
    };

    // Get the GUID of the resource, and then get the resource fields.
    function setResourceInfo() {
        getResourceGuid().then(
            function (data) {
                setResourceFields(data);
            }
        );
    }

    // Get the GUID of the selected resource.
    function getResourceGuid() {
        const defer = $.Deferred();
        Office.context.document.getSelectedResourceAsync(
            function (result) {
                if (result.status === Office.AsyncResultStatus.Failed) {
                    onError(result.error);
                }
                else {
                    defer.resolve(result.value);
                }
            }
        );
        return defer.promise();
    }

    // Set the specified fields for the selected resource.
    function setResourceFields(resourceGuid) {
        const targetFields = [Office.ProjectResourceFields.StandardRate, Office.ProjectResourceFields.Notes];
        const fieldValues = [.28, 'Notes for the resource.'];

        // Set the field value. If the call is successful, set the next field.
        for (let i = 0; i < targetFields.length; i++) {
            Office.context.document.setResourceFieldAsync(
                resourceGuid,
                targetFields[i],
                fieldValues[i],
                function (result) {
                    if (result.status === Office.AsyncResultStatus.Succeeded) {
                        i++;
                    }
                    else {
                        onError(result.error);
                    }
                }
            );
        }
        $('#message').html('Field values set');
    }

    function onError(error) {
        app.showNotification(error.name + ' ' + error.code + ': ' + error.message);
    }
})();

setSelectedDataAsync(data, options, callback)

Schreibt die angegebenen Daten in die aktuelle Auswahl.

setSelectedDataAsync(data: string | TableData | any[][], options?: SetSelectedDataOptions, callback?: (result: AsyncResult<void>) => void): void;

Parameter

data: string | Office.TableData | any[][]

Die festzulegenden Daten. Entweder eine Zeichenfolge oder ein Office.CoercionType-Wert , ein 2D-Array oder ein TableData-Objekt.

Wenn der für data übergebene Wert lautet:

Eine Zeichenfolge: Nur-Text oder alle Werte, die in eine Zeichenfolge umgewandelt werden können, werden eingefügt. In Excel können Sie daten auch als gültige Formel angeben, um diese Formel der ausgewählten Zelle hinzuzufügen. Indem Sie den Wert data auf "=SUM(A1:A5)" setzen, wird das Ergebnis der Werte des angegebenen Bereichs angezeigt. Wenn Sie jedoch eine Formel für die gebundene Zelle festlegen, können Sie die hinzugefügte Formel (oder eine bereits vorhandene Formel) anschließend nicht mehr aus der gebundenen Zelle lesen. Wenn Sie die Document.getSelectedDataAsyncMethode in der ausgewählten Zelle aufrufen, um die Daten zu lesen, kann die Methode nur die in der Zelle angezeigten Daten (das Formelergebnis) zurückgeben.
Ein Array von Arrays („Matrix“): Es werden tabellarische Daten ohne Kopfzeilen eingefügt. Wenn z. B. Daten in drei Zeilen in zwei Spalten geschrieben werden sollen, können Sie ein Array wie das Folgende übergeben: [["R1C1", "R1C2"], ["R2C1", "R2C2"], ["R3C1", "R3C2"]]. Wenn nur eine Spalte dieser drei Zeilen geschrieben werden soll, übergeben Sie ein Array wie dieses: [["R1C1"], ["R2C1"], ["R3C1"]]

In Excel können Sie auch data als ein Array von Arrays mit gültigen Formeln angeben, um diese Formeln zu den ausgewählten Zellen hinzuzufügen. Wenn keine weiteren Daten überschrieben werden, Werden diese beiden Formeln durch das Setzen von data auf [["=SUM(A1:A5)","=AVERAGE(A1:A5)"]] der Auswahl hinzugefügt. Genau wie beim Angeben einer Formel für eine einzelne Zelle als „Text“, können Sie die hinzugefügten Formeln (oder bereits vorhandene Formeln) anschließend nicht mehr lesen. Sie können nur die Formelergebnisse lesen.

Ein TableData-Objekt: Eine Tabelle mit Kopfzeilen wird eingefügt. Wenn Sie in Excel die Formeln im TableData-Objekt angeben, dass Sie für den data-Parameter weitergeben, erhalten Sie wegen der "berechnete Spalten"-Funktion möglicherweise nicht die erwarteten Ergebnisse, die die Formeln innerhalb einer Spalte automatisch dupliziert. Um dies zu umgehen, wenn Sie Formeln in eine ausgewählte Tabelle schreiben data möchten, versuchen Sie, die Daten als Array von Arrays (anstelle eines TableData-Objekts) anzugeben, und geben Sie den coercionType als Microsoft.Office.Matrix oder "matrix" an. Diese Technik blockiert jedoch das Feature "berechnete Spalten" nur, wenn eine der folgenden Bedingungen erfüllt ist: (1) Sie schreiben in alle Zellen der Spalte, oder (2) es gibt bereits mindestens zwei verschiedene Formeln in der Spalte.

options: Office.SetSelectedDataOptions

Stellt Optionen zum Einfügen von Daten in die Auswahl bereit.

callback: (result: Office.AsyncResult<void>) => void

Optional. Eine Funktion, die aufgerufen wird, wenn der Rückruf zurückgibt, deren einziger Parameter vom Typ Office.AsyncResult ist. Die AsyncResult.value-Eigenschaft gibt immer zurück undefined , da kein Objekt oder keine Daten abgerufen werden müssen.

Gibt zurück

void

Hinweise

Anforderungssätze:

HtmlCoercion, (bei Verwendung von Office.CoercionType.Html)
ImageCoercion 1.1 (bei Verwendung von Office.CoercionType.Image)
MatrixCoercion (bei Verwendung von Office.CoercionType.Matrix)
OoxmlCoercion (bei Verwendung von Office.CoercionType.Ooxml)
Selection
TableCoercion (bei Verwendung von Office.CoercionType.Table)
TextCoercion (bei Verwendung von Office.CoercionType.Text)
ImageCoercion 1.2 (bei Verwendung von Office.CoercionType.XmlSvg)

Anwendungsspezifische Verhaltensweisen

Die folgenden anwendungsspezifischen Aktionen gelten beim Schreiben von Daten in eine Auswahl.

Word	Wenn keine Markierung vorhanden ist und sich die Einfügemarke an einer gültigen Position befindet, wird die angegebene `data` an der Einfügemarke eingefügt.	Wenn `data` eine Zeichenfolge ist, wird der angegebene Text eingefügt.
		Wenn `data` ein Array von Arrays ("Matrix") oder ein TableData-Objekt ist, wird eine neue Word Tabelle eingefügt.
		Wenn daten HTML sind, wird der angegebene HTML-Code eingefügt. (Wichtig: Wenn einer der html-Code, den Sie einfügen, ungültig ist, löst Word keinen Fehler aus. Word fügt so viel HTML wie möglich ein und lässt ungültige Daten aus.
		Wenn `data` Office Open XML ist, wird der angegebene XML-Code eingefügt.
		Wenn `data` ein Base64-codierter Bildstream ist, wird das angegebene Bild eingefügt.
	Wenn eine Auswahl vorhanden ist	Es wird durch den angegebenen `data` ersetzt, wobei die gleichen Regeln wie oben gelten.
	Einfügen von Bildern	Eingefügte Bilder werden inline platziert. Die Parameter imageLeft und imageTop werden ignoriert. Das Bildseitenverhältnis ist immer gesperrt. Wenn nur einer der Parameter imageWidth und imageHeight angegeben ist, wird der andere Wert automatisch skaliert, um das ursprüngliche Seitenverhältnis beizubehalten.
Excel	Wenn eine einzelne Zelle ausgewählt ist	Wenn `data` eine Zeichenfolge ist, wird der angegebene Text als Wert der aktuellen Zelle eingefügt.
		Wenn `data` ein Array von Arrays ("Matrix") ist, wird der angegebene Satz von Zeilen und Spalten eingefügt, wenn keine anderen Daten in umgebenden Zellen überschrieben werden.
		Wenn `data` ein TableData-Objekt ist, wird eine neue Excel-Tabelle mit dem angegebenen Satz von Zeilen und Überschriften eingefügt, wenn keine anderen Daten in umgebenden Zellen überschrieben werden.
	Wenn mehrere Zellen ausgewählt sind	Wenn das Shape nicht mit der Form von `data`übereinstimmt, wird ein Fehler zurückgegeben.
		Wenn die Form der Auswahl genau mit der Form von `data`übereinstimmt, werden die Werte der ausgewählten Zellen basierend auf den Werten in `data`aktualisiert.
	Einfügen von Bildern	Eingefügte Bilder sind schwebend. Die Parameter "imageLeft" und "imageTop" sind relativ zu den aktuell ausgewählten Zellen. Negative Werte für imageLeft und imageTop sind zulässig und werden möglicherweise von Excel an die Bildposition innerhalb eines Arbeitsblatts angepasst. Das Bild-Seitenverhältnis ist gesperrt, es sei denn, die beiden Parameter imageWidth und imageHeight werden angegeben. Wenn nur einer der Parameter imageWidth und imageHeight angegeben ist, wird der andere Wert automatisch skaliert, um das ursprüngliche Seitenverhältnis beizubehalten.
	Alle anderen Fälle	Ein Fehler wird zurückgegeben.
Excel im Web	Zusätzlich zu den oben für Excel beschriebenen Verhaltensweisen gelten diese Grenzwerte beim Schreiben von Daten in Excel im Web	Die Gesamtanzahl der Zellen, die Sie in ein Arbeitsblatt schreiben können, mit dem `data` -Parameter darf 20.000 in einem einzelnen Aufruf dieser Methode nicht überschreiten.
		Die Anzahl der an den `cellFormat` Parameter übergebenen Formatierungsgruppen darf 100 nicht überschreiten. Eine einzelne Formatierungsgruppe besteht aus einem Formatierungssatz, der auf einen bestimmten Zellenbereich angewendet wird.
PowerPoint	Bild einfügen	Eingefügte Bilder sind schwebend. Die parameter position imageLeft und imageTop sind optional, aber sofern angegeben, sollten beide vorhanden sein. Wenn ein einzelner Wert bereitgestellt wird, wird er ignoriert. Negative Wert für imageLeft und imageTop sind zulässig und können ein Bild außerhalb einer Folie positionieren. Wenn keine optionaler Parameter angegeben ist und die Folie einen Platzhalter aufweist, ersetzt das Bild den Platzhalter auf der Folie. Das Bild-Seitenverhältnis wird gesperrt, es sei denn, die beiden Parameter imageWidth und imageHeight werden angegeben. Wenn nur einer der Parameter imageWidth und imageHeight angegeben ist, wird der andere Wert automatisch skaliert, um das ursprüngliche Seitenverhältnis beizubehalten.

Anwendungen

Die möglichen Werte für den Office.CoercionType-Parameter variieren je nach Office-Anwendung.

`CoercionType`	Unterstützte Anwendungen
`Office.CoercionType.Html`	– Word
`Office.CoercionType.Matrix` (Array von Arrays)	-Excel – Word
`Office.CoercionType.Ooxml` (Office Open XML)	– Word
`Office.CoercionType.SlideRange`	– PowerPoint im Web und unter Windows
`Office.CoercionType.Table` (TableData-Objekt)	-Excel – Word
`Office.CoercionType.Text` (Zeichenfolge)	-Excel -Powerpoint -Projekt – Word
`Office.CoercionType.XmlSvg`	– Excel unter Windows und auf Mac – PowerPoint unter Windows, auf Mac und im Web – Word unter Windows und macos

Beispiele

// The following example sets the selected text or cell to "Hello World!", 
// and if that fails, displays the value of the error.message property.
function writeText() {
    Office.context.document.setSelectedDataAsync("Hello World!",
        function (asyncResult) {
            const error = asyncResult.error;
            if (asyncResult.status === Office.AsyncResultStatus.Failed){
                write(error.name + ": " + error.message);
            }
        });
}

// Function that writes to a div with id='message' on the page.
function write(message){
    document.getElementById('message').innerText += message; 
}

// Specifying the optional coercionType parameter lets you specify the kind of data you want to write
// to a selection. The following example writes data as an array of three rows of two columns, 
// specifying the coercionType as `Matrix` for that data structure, and if that fails, 
// displays the value of the error.message property.
function writeMatrix() {
    Office.context.document.setSelectedDataAsync(
        [["Red", "Rojo"], ["Green", "Verde"], ["Blue", "Azul"]],
        {coercionType: Office.CoercionType.Matrix}
        function (asyncResult) {
            const error = asyncResult.error;
            if (asyncResult.status === Office.AsyncResultStatus.Failed){
                write(error.name + ": " + error.message);
            }
        });
}

// Function that writes to a div with id='message' on the page.
function write(message){
    document.getElementById('message').innerText += message; 
}

// The following example writes data as a one column table with a header and four rows, 
// specifying the coercionType as `Table` for that data structure, and if that fails, 
// displays the value of the error.message property.
function writeTable() {
    // Build table.
    const myTable = new Office.TableData();
    myTable.headers = [["Cities"]];
    myTable.rows = [['Berlin'], ['Roma'], ['Tokyo'], ['Seattle']];

    // Write table.
    Office.context.document.setSelectedDataAsync(myTable, {coercionType: Office.CoercionType.Table},
        function (result) {
            const error = result.error
            if (result.status === Office.AsyncResultStatus.Failed) {
                write(error.name + ": " + error.message);
            }
    });
}

// Function that writes to a div with id='message' on the page.
function write(message){
    document.getElementById('message').innerText += message; 
}

// In Word if you want to write HTML to the selection, you can specify the coercionType parameter as `Html`
// as shown in the following example, which uses HTML <b> tags to make "Hello" bold.
function writeHtmlData() {
    Office.context.document.setSelectedDataAsync(
        "<b>Hello</b> World!", {coercionType: Office.CoercionType.Html}, function (asyncResult) {
            if (asyncResult.status === Office.AsyncResultStatus.Failed) {
                write('Error: ' + asyncResult.error.message);
            }
    });
}

// Function that writes to a div with id='message' on the page.
function write(message){
    document.getElementById('message').innerText += message; 
}

// In Word, PowerPoint, or Excel, if you want to write an image to the selection, you can specify the coercionType
// parameter as `Image` as shown in the following example. Note that imageLeft and imageTop are ignored by Word.
function insertPictureAtSelection(base64EncodedImageStr) {

    Office.context.document.setSelectedDataAsync(base64EncodedImageStr, {
        coercionType: Office.CoercionType.Image,
        imageLeft: 50,
        imageTop: 50,
        imageWidth: 100,
        imageHeight: 100
    },
    function (asyncResult) {
        if (asyncResult.status === Office.AsyncResultStatus.Failed) {
            console.log("Action failed with error: " + asyncResult.error.message);
        }
    });
}

// In Word, PowerPoint, or Excel, if you want to write an scalable vector graphic (SVG) to the selection, you can specify the 
// coercionType parameter as `XmlSvg` as shown in the following example. Note that imageLeft and imageTop are ignored by Word.
function insertSvgAtSelection(base64EncodedImageStr) {
    Office.context.document.setSelectedDataAsync(getImageAsBase64String(), {
        coercionType: Office.CoercionType.XmlSvg,
        imageLeft: 50,
        imageTop: 50,
        imageWidth: 400
    },
        function (asyncResult) {
            if (asyncResult.status === Office.AsyncResultStatus.Failed) {
                console.log(asyncResult.error.message);
            }
        });
}

setSelectedDataAsync(data, callback)

Schreibt die angegebenen Daten in die aktuelle Auswahl.

setSelectedDataAsync(data: string | TableData | any[][], callback?: (result: AsyncResult<void>) => void): void;

Parameter

data: string | Office.TableData | any[][]

Die festzulegenden Daten. Entweder eine Zeichenfolge oder ein Office.CoercionType-Wert , ein 2D-Array oder ein TableData-Objekt.

Wenn der für data übergebene Wert lautet:

Eine Zeichenfolge: Nur-Text oder alle Werte, die in eine Zeichenfolge umgewandelt werden können, werden eingefügt. In Excel können Sie daten auch als gültige Formel angeben, um diese Formel der ausgewählten Zelle hinzuzufügen. Indem Sie den Wert data auf "=SUM(A1:A5)" setzen, wird das Ergebnis der Werte des angegebenen Bereichs angezeigt. Wenn Sie jedoch eine Formel für die gebundene Zelle festlegen, können Sie die hinzugefügte Formel (oder eine bereits vorhandene Formel) anschließend nicht mehr aus der gebundenen Zelle lesen. Wenn Sie die Document.getSelectedDataAsyncMethode in der ausgewählten Zelle aufrufen, um die Daten zu lesen, kann die Methode nur die in der Zelle angezeigten Daten (das Formelergebnis) zurückgeben.
Ein Array von Arrays („Matrix“): Es werden tabellarische Daten ohne Kopfzeilen eingefügt. Wenn z. B. Daten in drei Zeilen in zwei Spalten geschrieben werden sollen, können Sie ein Array wie das Folgende übergeben: [["R1C1", "R1C2"], ["R2C1", "R2C2"], ["R3C1", "R3C2"]]. Wenn nur eine Spalte dieser drei Zeilen geschrieben werden soll, übergeben Sie ein Array wie dieses: [["R1C1"], ["R2C1"], ["R3C1"]]

Ein TableData-Objekt: Eine Tabelle mit Kopfzeilen wird eingefügt. Wenn Sie in Excel die Formeln im TableData-Objekt angeben, dass Sie für den data-Parameter weitergeben, erhalten Sie wegen der "berechnete Spalten"-Funktion möglicherweise nicht die erwarteten Ergebnisse, die die Formeln innerhalb einer Spalte automatisch dupliziert. Um dies zu umgehen, wenn Sie Formeln in eine ausgewählte Tabelle schreiben data möchten, versuchen Sie, die Daten als Array von Arrays (anstelle eines TableData-Objekts) anzugeben, und geben Sie den coercionType als Microsoft.Office.Matrix oder "matrix" an. Diese Technik blockiert jedoch das Feature "berechnete Spalten" nur, wenn eine der folgenden Bedingungen erfüllt ist: (1) Sie schreiben in alle Zellen der Spalte, oder (2) es gibt bereits mindestens zwei verschiedene Formeln in der Spalte.

callback: (result: Office.AsyncResult<void>) => void

Gibt zurück

void

Hinweise

Anforderungssätze:

HtmlCoercion, (bei Verwendung von Office.CoercionType.Html)
ImageCoercion (bei Verwendung von Office.CoercionType.Image)
MatrixCoercion (bei Verwendung von Office.CoercionType.Matrix)
OoxmlCoercion (bei Verwendung von Office.CoercionType.Ooxml)
Selection
TableCoercion (bei Verwendung von Office.CoercionType.Table)
TextCoercion (bei Verwendung von Office.CoercionType.Text)
ImageCoercion 1.2 (bei Verwendung von Office.CoercionType.XmlSvg)

Anwendungsspezifische Verhaltensweisen

Die folgenden anwendungsspezifischen Aktionen gelten beim Schreiben von Daten in eine Auswahl.

Word	Wenn keine Markierung vorhanden ist und sich die Einfügemarke an einer gültigen Position befindet, werden die angegebenen "daten" an der Einfügemarke eingefügt.	Wenn `data` eine Zeichenfolge ist, wird der angegebene Text eingefügt.
		Wenn `data` ein Array von Arrays ("Matrix") oder ein TableData-Objekt ist, wird eine neue Word Tabelle eingefügt.
		Wenn `data` HTML ist, wird der angegebene HTML-Code eingefügt. (Wichtig: Wenn einer der html-Code, den Sie einfügen, ungültig ist, löst Word keinen Fehler aus. Word fügt so viel HTML wie möglich ein und lässt ungültige Daten aus.
		Wenn `data` Office Open XML ist, wird der angegebene XML-Code eingefügt.
		Wenn `data` ein Base64-codierter Bildstream ist, wird das angegebene Bild eingefügt.
	Wenn eine Auswahl vorhanden ist	Es wird durch den angegebenen `data` ersetzt, wobei die gleichen Regeln wie oben gelten.
	Einfügen von Bildern	Eingefügte Bilder werden inline platziert. Die Parameter imageLeft und imageTop werden ignoriert. Das Bildseitenverhältnis ist immer gesperrt. Wenn nur einer der Parameter imageWidth und imageHeight angegeben ist, wird der andere Wert automatisch skaliert, um das ursprüngliche Seitenverhältnis beizubehalten.
Excel	Wenn eine einzelne Zelle ausgewählt ist	Wenn `data` eine Zeichenfolge ist, wird der angegebene Text als Wert der aktuellen Zelle eingefügt.
		Wenn `data` ein Array von Arrays ("Matrix") ist, wird der angegebene Satz von Zeilen und Spalten eingefügt, wenn keine anderen Daten in umgebenden Zellen überschrieben werden.
		Wenn `data` ein TableData-Objekt ist, wird eine neue Excel-Tabelle mit dem angegebenen Satz von Zeilen und Überschriften eingefügt, wenn keine anderen Daten in umgebenden Zellen überschrieben werden.
	Wenn mehrere Zellen ausgewählt sind	Wenn das Shape nicht mit der Form von `data`übereinstimmt, wird ein Fehler zurückgegeben.
		Wenn die Form der Auswahl genau mit der Form von `data`übereinstimmt, werden die Werte der ausgewählten Zellen basierend auf den Werten in `data`aktualisiert.
	Einfügen von Bildern	Eingefügte Bilder sind schwebend. Die Parameter "imageLeft" und "imageTop" sind relativ zu den aktuell ausgewählten Zellen. Negative Werte für imageLeft und imageTop sind zulässig und werden möglicherweise von Excel an die Bildposition innerhalb eines Arbeitsblatts angepasst. Das Bild-Seitenverhältnis ist gesperrt, es sei denn, die beiden Parameter imageWidth und imageHeight werden angegeben. Wenn nur einer der Parameter imageWidth und imageHeight angegeben ist, wird der andere Wert automatisch skaliert, um das ursprüngliche Seitenverhältnis beizubehalten.
	Alle anderen Fälle	Ein Fehler wird zurückgegeben.
Excel im Web	Zusätzlich zu den oben für Excel beschriebenen Verhaltensweisen gelten diese Grenzwerte beim Schreiben von Daten in Excel im Web	Die Gesamtanzahl der Zellen, die Sie in ein Arbeitsblatt schreiben können, mit dem `data` -Parameter darf 20.000 in einem einzelnen Aufruf dieser Methode nicht überschreiten.
		Die Anzahl der an den `cellFormat` Parameter übergebenen Formatierungsgruppen darf 100 nicht überschreiten. Eine einzelne Formatierungsgruppe besteht aus einem Formatierungssatz, der auf einen bestimmten Zellenbereich angewendet wird.
PowerPoint	Bild einfügen	Eingefügte Bilder sind schwebend. Die parameter position imageLeft und imageTop sind optional, aber sofern angegeben, sollten beide vorhanden sein. Wenn ein einzelner Wert bereitgestellt wird, wird er ignoriert. Negative Wert für imageLeft und imageTop sind zulässig und können ein Bild außerhalb einer Folie positionieren. Wenn keine optionaler Parameter angegeben ist und die Folie einen Platzhalter aufweist, ersetzt das Bild den Platzhalter auf der Folie. Das Bild-Seitenverhältnis wird gesperrt, es sei denn, die beiden Parameter imageWidth und imageHeight werden angegeben. Wenn nur einer der Parameter imageWidth und imageHeight angegeben ist, wird der andere Wert automatisch skaliert, um das ursprüngliche Seitenverhältnis beizubehalten.

Anwendungen

Die möglichen Werte für den Office.CoercionType-Parameter variieren je nach Office-Anwendung.

`CoercionType`	Unterstützte Anwendungen
`Office.CoercionType.Html`	– Word
`Office.CoercionType.Matrix` (Array von Arrays)	-Excel – Word
`Office.CoercionType.Ooxml` (Office Open XML)	– Word
`Office.CoercionType.SlideRange`	– PowerPoint im Web und unter Windows
`Office.CoercionType.Table` (TableData-Objekt)	-Excel – Word
`Office.CoercionType.Text` (Zeichenfolge)	-Excel -Powerpoint -Projekt – Word
`Office.CoercionType.XmlSvg`	– Excel unter Windows und auf Mac – PowerPoint unter Windows, auf Mac und im Web – Word unter Windows und macos

setTaskFieldAsync(taskId, fieldId, fieldValue, options, callback)

Nur Projektdokumente. Legen Sie das Vorgangsfeld für die angegebene Vorgangs-ID fest.

Wichtig: Diese API funktioniert nur in Project 2016 auf Dem Windows-Desktop.

setTaskFieldAsync(taskId: string, fieldId: number, fieldValue: string | number | boolean | object, options?: Office.AsyncContextOptions, callback?: (result: AsyncResult<void>) => void): void;

Parameter

taskId: string

Entweder eine Zeichenfolge oder ein Wert der Aufgaben-ID.

fieldId: number

Aufgabenfelder.

fieldValue: string | number | boolean | object

Wert des Zielfelds.

options: Office.AsyncContextOptions

Bietet eine Option zum Beibehalten von Kontextdaten eines beliebigen Typs , unverändert, für die Verwendung in einem Rückruf.

callback: (result: Office.AsyncResult<void>) => void

Optional. Eine Funktion, die aufgerufen wird, wenn der Rückruf zurückgibt, deren einziger Parameter vom Typ Office.AsyncResult ist.

Gibt zurück

void

setTaskFieldAsync(taskId, fieldId, fieldValue, callback)

Nur Projektdokumente. Legen Sie das Vorgangsfeld für die angegebene Vorgangs-ID fest.

Wichtig: Diese API funktioniert nur in Project 2016 auf Dem Windows-Desktop.

setTaskFieldAsync(taskId: string, fieldId: number, fieldValue: string | number | boolean | object, callback?: (result: AsyncResult<void>) => void): void;

Parameter

taskId: string

Entweder eine Zeichenfolge oder ein Wert der Aufgaben-ID.

fieldId: number

Aufgabenfelder.

fieldValue: string | number | boolean | object

Wert des Zielfelds.

callback: (result: Office.AsyncResult<void>) => void

Optional. Eine Funktion, die aufgerufen wird, wenn der Rückruf zurückgibt, deren einziger Parameter vom Typ Office.AsyncResult ist.

Gibt zurück

void

Beispiele

// The following code example calls getSelectedTaskAsync to get the GUID of the task that's
// currently selected in a task view. Then it sets two task field values by calling
// setTaskFieldAsync recursively.
// The getSelectedTaskAsync method used in the example requires that a task view
// (for example, Task Usage) is the active view and that a task is selected. See the
// addHandlerAsync method for an example that activates a button based on the active view type.
// The example assumes your add-in has a reference to the jQuery library and that the
// following page controls are defined in the content div in the page body:
// <input id="set-info" type="button" value="Set info" /><br />
// <span id="message"></span>

(function () {
    "use strict";

    // The initialize function must be run each time a new page is loaded.
    Office.initialize = function (reason) {
        $(document).ready(function () {
            
            // After the DOM is loaded, add-in-specific code can run.
            app.initialize();
            $('#set-info').on("click", setTaskInfo);
        });
    };

    // Get the GUID of the task, and then get the task fields.
    function setTaskInfo() {
        getTaskGuid().then(
            function (data) {
                setTaskFields(data);
            }
        );
    }

    // Get the GUID of the selected task.
    function getTaskGuid() {
        const defer = $.Deferred();
        Office.context.document.getSelectedTaskAsync(
            function (result) {
                if (result.status === Office.AsyncResultStatus.Failed) {
                    onError(result.error);
                }
                else {
                    defer.resolve(result.value);
                }
            }
        );
        return defer.promise();
    }

    // Set the specified fields for the selected task.
    function setTaskFields(taskGuid) {
        const targetFields = [Office.ProjectTaskFields.Active, Office.ProjectTaskFields.Notes];
        const fieldValues = [true, 'Notes for the task.'];

        // Set the field value. If the call is successful, set the next field.
        for (let i = 0; i < targetFields.length; i++) {
            Office.context.document.setTaskFieldAsync(
                taskGuid,
                targetFields[i],
                fieldValues[i],
                function (result) {
                    if (result.status === Office.AsyncResultStatus.Succeeded) {
                        i++;
                    }
                    else {
                        onError(result.error);
                    }
                }
            );
        }
        $('#message').html('Field values set');
    }

    function onError(error) {
        app.showNotification(error.name + ' ' + error.code + ': ' + error.message);
    }
})();