Como: de forma programática fazer backup de conteúdo

Artigo
11/27/2008

Este tópico explica como ao programa um de backup de um de conteúdo Windows SharePoint Services 3.0 wssversion3 componente. O tópico pressupõe que você é familiarizado com Visão geral sobre backup e restaurando os dados nos serviços SharePoint Windows e Programação com o modelo de objeto de backup/restauração de serviços SharePoint Windows.

Para fazer o backup um componente de conteúdo

Adicione uma referência a serviços SharePoint Windows para seu projeto Visual Studio e adicionar using instruções para o Microsoft.SharePoint.Administration e Microsoft.SharePoint.Administration.Backup espaços para nome para você usando codificar arquivo.

O método principal, prompt dentro de usuário para especificar onde o de backup deve ser armazenada.

                        Console.Write("Enter full UNC path to the directory where the backup will be stored:");
String backupLocation = Console.ReadLine();

Inside the Main method, create a SPBackupSettings object by using the static GetBackupSettings method. Para transmitir o parâmetro primeiro o caminho onde o de backup deve ser armazenada. Para transmitir o segundo parâmetro Uma versão seqüência de caracteres de um dos valores de SPBackupMethodType.
```
                        SPBackupSettings settings = SPBackupRestoreSettings.GetBackupSettings(backupLocation, "Full");
```
Solicita o usuário para especificar o de conteúdo componente para voltar e atribuir seu nome para o IndividualItem P:Microsoft.SharePoint.Administration.Backup.SPBackupRestoreSettings.IndividualItem propriedade. To see an itemization of the names of the components on your farm that can be the objects of backup operations, you can either run the command stsadm -o backup -showtree at the server command line or visit Operations > Perform a Backup in the Central Administration application. Para especificar todo o farm, use "farm" como o nome. (Setting the property to null also selects the whole farm for backup assuming that you use IndividualItem in all subsequent code to identify by name the component to be backed up, as you should. Para obter um exemplo, consulte o uso do FindItems M:Microsoft.SharePoint.Administration.Backup.SPBackupRestoreConsole.FindItems método na etapa 8.)
```
                        Console.Write("Enter name of component to backup (default is whole farm):");
settings.IndividualItem = Console.ReadLine();
```
Optionally, set one or more of the IsVerbose, UpdateProgress, and BackupTheads properties. (Para obter detalhes sobre essas propriedades, consulte os tópicos de referência para eles.)
```
                        settings.IsVerbose = true;
settings.UpdateProgress = 10;
settings.BackupThreads = 2;
```
Criar o de backup operação com o CreateBackupRestore método M:Microsoft.SharePoint.Administration.Backup.SPBackupRestoreConsole.CreateBackupRestore. (Um objeto histórico para a operação também é criado). Para obter mais informações, consulte SPBackupRestoreHistoryObject e SPBackupRestoreHistoryList.)
```
                        Guid backup = SPBackupRestoreConsole.CreateBackupRestore(settings);
```
Se seu interface do usuário tiver usuários tipo um nome componente instead of escolher um de uma lista, você deve certificar-se de que o nome inserido corresponde exatamente um componente. Adicione a seguinte linha ao seu método principal.
```
                        SPBackupRestoreObject node = EnsureUniqueValidComponentName(settings, ref backup);
```

Adicione o seguinte implementação de seu EnsureUniqueValidComponentName método. Use o método FindItems M:Microsoft.SharePoint.Administration.Backup.SPBackupRestoreConsole.FindItems para recuperar uma coleção de de conteúdo objetos cujos nomes corresponder ao nome digitado pelo usuário. Se não houver nenhuma correspondência, prompt o usuário para tentar novamente. Se houver mais de uma, prompt o usuário ser mais específico. Se o componente nome que o usuário digitado é válido e get não ambígua, uma referência para o objeto SPBackupRestoreObject T:Microsoft.SharePoint.Administration.Backup.SPBackupRestoreObject que representa o componente que o usuário quer para restaurar.

                        private static SPBackupRestoreObject EnsureUniqueValidComponentName(SPBackupRestoreSettings settings, ref Guid operationGUID)
{
    SPBackupRestoreObjectCollection list = SPBackupRestoreConsole.FindItems(operationGUID, settings.IndividualItem);
    SPBackupRestoreObject component = null;

    if (list.Count <= 0)
    {
        Console.WriteLine("There is no component with that name. Run again with a new name.");
        Console.WriteLine("Press Enter to continue.");
        Console.ReadLine();
    }
    else if (list.Count > 1)  // The component name specified is ambiguous. Prompt user to be more specific.
    {
        Console.WriteLine("More than one component matches the name you entered.");
        Console.WriteLine("Run again with one of the following:");
        for (int i = 0; i < list.Count; i++)
        {
            Console.WriteLine("\t{0}", list[i].ToString());
        }
        Console.WriteLine("Press Enter to continue.");
        Console.ReadLine();
    }
    else
    {
        component = list[0];
    }

    return component;

}

No método principal, crie um Boolean T:System.Boolean sinalizador que irá sinal se há espaço suficiente para o de backup e uma estrutura condicional que será executar somente se o seu EnsureUniqueValidComponentName método retornou um válido nó.
```
                        Boolean targetHasEnoughSpace = false;
if (node != null)
{
    targetHasEnoughSpace = EnsureEnoughDiskSpace(backupLocation, backup, node);
}
```

Adicione o seguinte implementação de seu EnsureEnoughDiskSpace método. Usar o DiskSizeRequired método M:Microsoft.SharePoint.Administration.Backup.SPBackupRestoreConsole.DiskSizeRequired para obter o quantidade de espaço que é necessário e o DiskSize M:Microsoft.SharePoint.Administration.Backup.SPBackupRestoreConsole.DiskSize método para determinar quanto espaço livre está disponível no disco de destino.

                        private static Boolean EnsureEnoughDiskSpace(String location, Guid backup, SPBackupRestoreObject node)
{
    UInt64 backupSize = SPBackupRestoreConsole.DiskSizeRequired(backup, node);
    UInt64 diskFreeSize = 0;
    UInt64 diskSize = 0;
    Boolean hasEnoughSpace = true;

    try
    {
        SPBackupRestoreConsole.DiskSize(location, out diskFreeSize, out diskSize);
    }
    catch
    {
        diskFreeSize = diskSize = UInt64.MaxValue;
    }

    if (backupSize > diskFreeSize)
    {
        // Report through your UI that there is not enough disk space.
        Console.WriteLine("{0} bytes of space is needed but the disk hosting {1} has only {2}.", backupSize, location, diskFreeSize);
        Console.WriteLine("Please try again with a different backup location or a smaller component.");
        hasEnoughSpace = false;
    }
    else if (backupSize == UInt64.MaxValue || diskFreeSize == 0)
    {
        // Report through your UI that it cannot be determined whether there is enough disk space.
        Console.WriteLine("Cannot determine if that location has enough disk space.");
        Console.WriteLine("Please try again with a different backup location or a smaller component.");
        hasEnoughSpace = false;
    }
    return hasEnoughSpace;

}

No método principal, crie uma estrutura condicional que irá executar somente se o seu EnsureEnoughDiskSpace Retorna true.

                        if (targetHasEnoughSpace)
{
    // TODO: Set the backup operation as the active operation
    // and run it.
}

Substituir a linha "tarefa" na etapa anterior com a seguinte codificar. Isso define a operação seja o ativo operação com o método SetActive M:Microsoft.SharePoint.Administration.Backup.SPBackupRestoreConsole.SetActive e testes para verificar que ele bem-sucedido. Se ele falhar, o qual ele irá se outra operação de backup ou restaurar já em andamento, está relatório de erro para o interface do usuário do seu aplicativo.
```
                        if (SPBackupRestoreConsole.SetActive(backup) == true)
{
    // TODO: Run the operation. See next step.
}
else
{
    // Report through your UI that another backup
    // or restore operation is underway. 
    Console.WriteLine("Another backup or restore operation is already underway. Try again when it ends.");
}
```
In the code branch that runs if the SetActive call succeeds, run the operation with the Run method. Teste se a operação tiver êxito. Se ele falhar, relatório falha mensagem da operação para o interface do usuário. O seguinte codificar substitui a linha "tarefa" a etapa anterior.
```
                        if (SPBackupRestoreConsole.Run(backup, node) == false)
{
    // Report "error" through your UI.
    String error = SPBackupRestoreConsole.Get(backup).FailureMessage;
    Console.WriteLine(error);
}
```
Limpe a restaurar com o Remove método M:Microsoft.SharePoint.Administration.Backup.SPBackupRestoreConsole.Remove. Adicione o seguinte codificar imediatamente antes de chave de fechamento é inserido na etapa 11.
```
                        // Clean up the operation.
SPBackupRestoreConsole.Remove(backup);

Console.WriteLine("Backup attempt complete. Press Enter to continue.");
Console.ReadLine();
```

Exemplo

O seguinte mostra codificar como ao programa um de backup de um de conteúdo componente.

                    using System;
using Microsoft.SharePoint.Administration;
using Microsoft.SharePoint.Administration.Backup;

namespace MyCompany.SharePoint.Administration.Backup
{
    class Backup
    {
        static void Main(string[] args)
        {
            // Identify the location for the backup storage.
            Console.Write("Enter full UNC path to the directory where the backup will be stored:");
            String backupLocation = Console.ReadLine();
            
            // Create the backup settings.
            SPBackupSettings settings = SPBackupRestoreSettings.GetBackupSettings(backupLocation, "Full");

            // Identify the content component to backup.
            Console.Write("Enter name of component to backup (default is whole farm):");
            settings.IndividualItem = Console.ReadLine();
            
            // Set optional operation parameters.
            settings.IsVerbose = true;
            settings.UpdateProgress = 10;
            settings.BackupThreads = 10;

            // Create the backup operation and return its ID.
            Guid backup = SPBackupRestoreConsole.CreateBackupRestore(settings);

            // Ensure that user has identified a valid and unique component.
            SPBackupRestoreObject node = EnsureUniqueValidComponentName(settings, ref backup);

            // Ensure that there is enough space.
            Boolean targetHasEnoughSpace = false;
            if (node != null)
            {
                targetHasEnoughSpace = EnsureEnoughDiskSpace(backupLocation, backup, node);
            }

            // If there is enough space, attempt to run the backup.
            if (targetHasEnoughSpace)
            {
                // Set the backup as the active job and run it.
                if (SPBackupRestoreConsole.SetActive(backup) == true)
                {
                    if (SPBackupRestoreConsole.Run(backup, node) == false)
                    {
                        // Report "error" through your UI.
                        String error = SPBackupRestoreConsole.Get(backup).FailureMessage;
                        Console.WriteLine(error);
                    }
                }
                else
                {
                    // Report through your UI that another backup
                    // or restore operation is underway. 
                    Console.WriteLine("Another backup or restore operation is already underway. Try again when it ends.");
                }

                // Clean up the operation.
                SPBackupRestoreConsole.Remove(backup);

                Console.WriteLine("Backup attempt complete. Press Enter to continue.");
                Console.ReadLine();
            }
        }// end Main

        private static SPBackupRestoreObject EnsureUniqueValidComponentName(SPBackupRestoreSettings settings, ref Guid operationGUID)
        {
            SPBackupRestoreObjectCollection list = SPBackupRestoreConsole.FindItems(operationGUID, settings.IndividualItem);
            SPBackupRestoreObject component = null;

            if (list.Count <= 0)
            {
                Console.WriteLine("There is no component with that name. Run again with a new name.");
                Console.WriteLine("Press Enter to continue.");
                Console.ReadLine();
            }
            else if (list.Count > 1)  // The component name specified is ambiguous. Prompt user to be more specific.
            {
                Console.WriteLine("More than one component matches the name you entered.");
                Console.WriteLine("Run again with one of the following:");
                for (int i = 0; i < list.Count; i++)
                {
                    Console.WriteLine("\t{0}", list[i].ToString());
                }
                Console.WriteLine("Press Enter to continue.");
                Console.ReadLine();
            }
            else
            {
                component = list[0];
            }

            return component;

        }// end EnsureUniqueValidComponentName

        private static Boolean EnsureEnoughDiskSpace(String location, Guid backup, SPBackupRestoreObject node)
        {
            UInt64 backupSize = SPBackupRestoreConsole.DiskSizeRequired(backup, node);
            UInt64 diskFreeSize = 0;
            UInt64 diskSize = 0;
            Boolean hasEnoughSpace = true;

            try
            {
                SPBackupRestoreConsole.DiskSize(location, out diskFreeSize, out diskSize);
            }
            catch
            {
                diskFreeSize = diskSize = UInt64.MaxValue;
            }

            if (backupSize > diskFreeSize)
            {
                // Report through your UI that there is not enough disk space.
                Console.WriteLine("{0} bytes of space is needed but the disk hosting {1} has only {2}.", backupSize, location, diskFreeSize);
                Console.WriteLine("Please try again with a different backup location or a smaller component.");
                hasEnoughSpace = false;
            }
            else if (backupSize == UInt64.MaxValue || diskFreeSize == 0)
            {
                // Report through your UI that it cannot be determined whether there is enough disk space.
                Console.WriteLine("Cannot determine if that location has enough disk space.");
                Console.WriteLine("Please try again with a different backup location or a smaller component.");
                hasEnoughSpace = false;
            }
            return hasEnoughSpace;

        }// end EnsureEnoughDiskSpace

    }// end Backup class
}// end namespace

Consulte também

Compartilhar via

Como: de forma programática fazer backup de conteúdo

Para fazer o backup um componente de conteúdo

Exemplo

Consulte também

Tarefas

Referência

Conceitos

Outros recursos

Recursos adicionais