Certains éditeurs fournissent des interfaces permettant de communiquer avec leurs applications par programmation. Cette capacité s'appelle l'interopérabilité. La technologie s'appelle l'automation.
Microsoft fournit des interfaces permettant de piloter les applications Office depuis une application .NET (cf. Qu'est-ce que l'automation Office ?) . Elles sont appelées Primary Interop Assemblies (cf. Que sont les Primary Interop Assemblies ?).
Cette citation, tirée de l'Aide et Support Microsoft, illustre bien les possibilités offertes par l'automation Office :

« Avec Automation, vous pouvez utiliser la fonctionnalité de publipostage de Microsoft Word pour générer des lettres types à partir de données 
d'une base de données sans que l'utilisateur se rende compte que Word est impliqué. 
Vous pouvez même utiliser toutes les fonctionnalités de graphiques et d'analyse de données de Microsoft Excel à l'aide d'Automation. 
Vous n'avez pas besoin d'écrire votre propre moteur de calcul pour fournir la multitude de fonctions mathématiques, financières et techniques fournies par Excel. 
Il vous suffit d'automatiser Microsoft Excel pour « emprunter » ces fonctionnalités et les incorporer dans votre propre application. »

Un autre moyen de communiquer avec un document Office, est de le considérer comme une base de données. C'est valable évidemment pour Access, mais aussi, et c'est moins connu, pour Excel.
Une troisième méthode est de manipuler directement le format natif des fichiers Office. C'est le cas du projet SourceForge Koogra qui permet de lire un fichier Excel à partir de son format natif BIFF (Binary Interchange File Format).
Depuis la version 2007 d'Office, un nouveau format a vu le jour, c'est le format OpenXML qui n'est autre qu'un fichier XML et donc aisément lisible et modifiable par programmation. Cependant, ce format n'est compatible que pour Office 2007 et éventuellement Office 2003, après avoir installé un patch permettant de lire ce format.
Enfin, sachez qu'il existe des librairies payantes de pilotage des applications Office. Nul besoin d'en dire plus, vous pourrez trouver toutes les informations nécessaires sur votre moteur de recherche préféré, avec des mots-clés tels que : read, write, excel, word, powerpoint, files, .net,…
Il est aussi possible de développer un Add-in pour Office ou de développer une application à partir d'un document Office. C'est ce que permettent les Visual Studio Tools pour Office (cf. Que sont les Visual Studio Tools for Office ?).

Cette définition de l'automation est tirée du Support Microsoft :

« Automation (anciennement OLE Automation) est une technologie qui vous permet de tirer parti d'une fonctionnalité ou du contenu d'un 
programme existant et de l'incorporer à vos propres applications. Automation est basé sur le composant COM (Component Object Model). 
COM est une architecture logicielle standard basée sur des interfaces, et conçue pour séparer le code en objets autonomes ou composants. 
Chaque composant expose un jeu d'interfaces par lesquelles toute la communication avec le composant est gérée.
Automation est constitué d'un serveur et d'un client. Le serveur Automation est l'application qui expose 
ses fonctionnalités au travers d'interfaces COM à d'autres applications, appelées clients Automation. »

L'automation Office est la technologie automation appliquée au modèle objet Office.

Les Primary Interop Assemblies (PIAs) sont des assemblys de code managé capables de communiquer avec les assemblys (de code non managé) du modèle objet Office. Cela est rendu possible parce que les assemblys du modèle objet Office exposent des interfaces COM.
Le mot "Primary" est utilisé lorsque ces assemblys sont fournis par l'éditeur. En l'occurrence, pour les assemblys Office, l'éditeur est Microsoft.
Attention, chaque version d'Office a ses propres versions de PIAs. Mais chaque version de PIAs est compatible avec les versions précédentes.
Il est possible de générer soi-même ces assemblys grâce à l'outil .NET TLBIMP. Ils s'appellent dans ce cas Interop assemblies (IAs). Mais il faut savoir que les PIAs sont optimisés par Microsoft. De plus, les types définis dans les IAs ne seront pas les mêmes que ceux définis dans les PIAs.
Exemple : le type Document d'un PIA est différent du type Document d'un IA ; qui lui-même est différent du type Document d'un autre IA.

Les PIAs sont disponibles dans les installations des applications Office version 2003 et supérieures. Ces modules sont intitulés Prise en charge de la programmabilité .NET (.NET Programmability support).
Certains PIAs sont aussi disponibles au téléchargement :
- Office XP
- Office 2003

Les PIAs s'installent dans le Global Assembly Cache (GAC) du poste.
Pour les versions 97 et 2000, les IAs sont générés par TLBIMP. Cette génération est automatisée dans Visual Studio lorsque les références sont ajoutées dans un projet.

Les outils Visual Studio pour Office permettent d'utiliser la technologie .NET à partir d'un document Office. Autrement dit, presque tout ce qu'il est possible de faire en winform ou webform est possible au sein du document Office.
Les outils Visual Studio pour Office ne sont valables qu'avec Office 2003 et 2007.
Attention : Les modèles de projet VSTO ne sont pas disponibles dans les versions Express de Visual Studio.

Pour pouvoir développer et exécuter des solutions VSTO, il faut installer le Runtime VSTO (VSTOR), dans sa version 2.0 pour Office 2003 et 3.0 pour Office 2007. Celui-ci est disponible sur le centre de téléchargement Microsoft avec le mot-clé : VSTOR.
Les autres composants indispensables sont :
- Le framework .NET
- Office 2003 ou 2007, dont :
* La programmabilité .NET (PIAs)
* Visual Basic pour Applications

1. Les ressources developpez.com
Les articles developpez.com sont un bon point de départ pour l'automation Office : les meilleurs cours et tutoriels C#.NET avec OFFICE.

2. La MSDN.
La MSDN regorge d'informations concernant l'automation Office et les modèles objet Office. Voici quelques points d'entrée intéressants :
Visual Studio Tools pour Office
Understanding the Excel Object Model from a Visual Studio 2005 Developer's Perspective
Understanding the Word Object Model from a Visual Studio 2005 Developer's Perspective

3. Les macros VBA.
Enregistrer une macro Office puis visualiser le code VBA généré permet de découvrir les objets Office utilisés et leurs paramètres. C'est très pratique lorsqu'on connaît la fonctionnalité à programmer mais qu'on ne connaît pas l'objet Office correspondant.

4. La documentation du modèle objet.
Office fournit une aide décrivant le modèle objet des applications avec des exemples d'utilisation en VBA. Cette aide se trouve dans le répertoire d'installation Office. Pour retrouver ces documents, voir : How to find and use Office object model documentation sur le centre d'aide et support.

Chaque version d'Office a ses propres PIAs. Mais, de la même façon qu'Office, chaque version des PIAs est compatible avec les versions précédentes.
Ainsi, pour être sûr d'être compatible avec un maximum de versions Office, le mieux est d'utiliser les PIAs les plus anciens. Tout ce qui fonctionne avec une version ancienne, fonctionnera avec une version plus récente d'Office.
D'un autre côté, une version ancienne ne permet pas de bénéficier des fonctions apparues dans les versions récentes d'Office.
En général, les assemblys de la version 9 d'Office (Office 2000) suffisent amplement.
Il faut savoir que le format des documents Office a été profondément modifié entre la version 8 (Office 97) et 9 (Office 2000). Par conséquent, l'automation Office avec des PIAs d'Office 97 pour des versions supérieures est déconseillée.
Tableau récapitulatif des versions d'Office et de leur appellation commerciale :

Nombreux sont ceux qui rencontrent ce problème : lorsque vous quittez une automation, vous utilisez (à quelques détails près) cette portion de code :

monAppli->Quit();
monAppli = nullptr;

Le plus souvent, ceci ne suffit pas à fermer le processus office : vous pouvez toujours le voir dans le gestionnaire des tâches. Ainsi, lorsque vous ouvrez le document, avec lequel vous avez travaillé par automation, depuis Windows, il refuse de l'ouvrir au titre qu'il est en cours d'utilisation par… vous-même !
Voilà donc quelques astuces pour libérer les ressources automation efficacement :
1. Déclarer les objets avec des variables indépendantes :
Par exemple, ne faites pas :

Workbook ^monClasseur = monAppli->Workbooks->Add();

Mais plutôt :

Workbooks ^mesClasseurs = monappli->Workbooks;
Workbook ^monClasseur = mesClasseurs->Add();

Pour une automation simple, cela peut passer ; mais pour une automation complexe, cela peut s'avérer extrêmement fastidieux !
2. Libérer les références aux objets COM :
Utilisez la méthode suivante pour libérer les références à vos objets COM :

System::Runtime::InteropServices::Marshal::ReleaseComObject(monAppli);

3. Utiliser le Garbage Collector (GC) :

GC::Collect();
GC::WaitForPendingFinalizers();

Il peut être utile de doubler cette portion, dans le cas où la référence mémoire du process est conservée après le premier appel.

4. Récupérer l'identifiant du processus office :
La méthode la plus définitive est de tuer le processus à la fin de l'automation.
Il faut pour cela, dans un premier temps, récupérer et stocker l'identifiant du processus pendant tout le temps que doit durer l'automation. Exemple pour une automation Word :

int processId = 0;
// 1. Additionner les identifiants des processus winword avant l'ouverture de l'automation :
for each (Process ^item in Process::GetProcessesByName("winword"))
	processId -= item.Id;
 
// 2. Ouvrir l'automation :
ApplicationClass ^monAppli = gcnew ApplicationClass();
 
// 3. Ajouter les identifiants des processus winword après l'ouverture de l'automation,
// la différence (après - avant) donnera l'identifiant du processus ouvert :
foreach (Process ^item in Process::GetProcessesByName("winword"))
	processId += item.Id;
 
// Automation...
 
// Enfin, lorsque l'automation est terminée, il suffit de tuer le processus à partir de son identifiant :
Process::GetProcessById(processId)->Kill();