Creation des points de restauration système

Soyez le premier à donner votre avis sur cette source.

Vue 10 938 fois - Téléchargée 463 fois

Description

Avec cette petite application, on peut ajouter des points de restauration système facilement grace a l'api windows
On peut ajouter, supprimer les points de restautration

Dans cette application, j'ai mis que l'operation d'ajout de points de restauration,
Il existe une source qui indique l'operation de suppression sur l'adresse suivante:

http://www.csharpfr.com/codes/SUPPRESSION-POINTS-RESTAURATION-WMI-WINDOWS-XP_32617.aspx

L'application supporte tous les SE
Les points de restauration sont surpportes sur les SE suivants
----------------------------
- Windows Me
- Windows XP
- Windows Vista
Non supporter sur le reste sauf Windows Server 2008 (Non testée)

En plus, elle necessite des droits administratifs pour qu'elle fonctionne correctement
Elle ne fonctionne pas en mode sans echec.

Le projet est réaliser avec Visual Studio 2008.

Source / Exemple :


using System;
using System.Runtime.InteropServices;
namespace CreateRestorePointCs
{
    /// <summary>
    /// System Restore Point
    /// Utiliser la fonction RestoreAvailable pour verifier si la restauration systeme est possible
    /// et puis appeler la fonction StartRestore avant d'ajouter des points de restauration 
    /// , et a la fin de modifications la fonction EndRestore.
    /// </summary>
    public class RestorePoint
    {

        private Int64 rpSequenceNumber; // variable globale.

        #region Public Constants
            // Constantes
            public const Int16 BeginSystemChange = 100; //Debut d'operation
            public const Int16 EndSystemChange= 101;    // fin d'operation
            // pour  Windows XP seulement - utilisees pour prevenir les points de restauration imbriques.
            public const Int16 BeginNestedSystemChange= 102;  
            public const Int16 EndNestedSystemChange= 103;    
            //---------------------------------------------
        #endregion
        #region Public Restore Type Enum

            // Type des points de restauration.
            public enum RestoreType
            {
                ApplicationInstall = 0,         // Installation d'une nouvelle application.
                ApplicationUninstall = 1,       // Désintallation d'une nouvelle application.
                ModifySettings = 12,            // Changement systeme.
                CancelledOperation = 13,        // END_SYSTEM_CHANGE
                Restore = 6,                    // Restauration du systeme.
                Checkpoint = 7,                 // Point de vérification.
                DeviceDriverInstall = 10,       // Installation d'un pilote.
                FirstRun = 11,                  // Utilisation pour la 1ere fois
                BackupRecovery = 14             // Restauration d'un backup.
            }

        #endregion
        #region Methods
            /// <summary>
            /// Vérifie si le systeme d'exploitation supporte les points de restauration
            /// </summary>
            /// <returns>Résultat de vérification.</returns>
            public bool RestoreAvailable()
            {
                int majorVersion = Environment.OSVersion.Version.Major;
                int minorVersion = Environment.OSVersion.Version.Minor;

                switch (Environment.OSVersion.Platform)
                {
                    case PlatformID.Win32Windows:
                        // Windows Me
                        if (minorVersion == 90)                     
                        {
                            return true;
                        }
                        else
                        {
                            return false;
                        }
                    case PlatformID.Win32NT:

                        switch (majorVersion)
                        {
                            case 5:
                                if (minorVersion == 0)
                                {
                                    return false;
                                }
                                // Windows XP
                                else if (minorVersion == 1)         
                                {
                                    return true;
                                }
                                // Windows Server 2003
                                else if (minorVersion == 2)         
                                {
                                    return false;
                                }
                                else
                                {
                                    return false;
                                }
                            case 6:
                                // Windows Vista
                                if (minorVersion == 0)              
                                {
                                    return true;
                                }
                                // Windows Server 2008
                                else if (minorVersion == 1)         
                                {
                                    // J'ai pas tester la fonction sous Windows Server 2008
                                    // Donc je retourne faux.
                                    return false;
                                }
                                else
                                {
                                    return false;
                                }
                            default:
                                return false;
                        }
                    default:
                        return false;
                 }
            }
            /// <summary>
            /// Début d'operations de modification.
            /// </summary>
            public bool StartRestore(string description, RestoreType lType)
            {
                // Informations sur le point de restauration
                NativeMethods.RestorePointInfo rpInfo;      
                // Etat du point de restauration
                NativeMethods.SystemManagerRestoreStatus rpStatus;
                // Si la derniere operation n' est pas terminee.
                if (rpSequenceNumber != 0)
                {
                      System.Windows.Forms.MessageBox.Show("Tu dois d'abord terminer le point de restauration.",
                        System.Windows.Forms.Application.ProductName, System.Windows.Forms.MessageBoxButtons.OK,
                        System.Windows.Forms.MessageBoxIcon.Asterisk);
                    return false;
                }
                // Preparation pour l'ajout
                rpInfo.dwEventType = BeginSystemChange;     // Type d'evenement: Debut d'operation.
                rpInfo.dwRestorePtType = (int) lType; // Selon le type passe pour la fonction.
                rpInfo.llSequenceNumber = 0;    // Debut d'operation
                rpInfo.szDescription = description; // selon la description passe en param
                // Si la preparation a réussit
                if (NativeMethods.SRSetRestorePointW(ref rpInfo, out rpStatus))
                {
                    // On prend le nouveau index du nouveau point (Apres passage pour la fonction native).
                    rpSequenceNumber = rpStatus.llSequenceNumber;
                    return true;
                }
                else
                {
                    return false;
                }
            }
            /// <summary>
            /// Verstion surchargée
            /// </summary>
            public bool StartRestore(string description)
            {
                // Tous les commentaires sont dans l'autre version de la fonction.
                NativeMethods.RestorePointInfo rpInfo;
                NativeMethods.SystemManagerRestoreStatus rpStatus;

                if (rpSequenceNumber != 0)
                {
                    System.Windows.Forms.MessageBox.Show("Tu dois d'abord terminer le point de restauration.",
                      System.Windows.Forms.Application.ProductName, System.Windows.Forms.MessageBoxButtons.OK,
                      System.Windows.Forms.MessageBoxIcon.Asterisk);
                    return false;
                }

                rpInfo.dwEventType = BeginSystemChange;
                // Par defaut on cree un point de vérification systeme
                rpInfo.dwRestorePtType = (int) RestoreType.Checkpoint;
                rpInfo.llSequenceNumber = 0;
                rpInfo.szDescription = description;

                if (NativeMethods.SRSetRestorePointW(ref rpInfo, out rpStatus))
                {
                    rpSequenceNumber = rpStatus.llSequenceNumber;
                    return true;
                }
                else
                {
                    return false;
                }
            }
            /// <summary>
            /// Fin de restauration system.
            /// </summary>
            public bool EndRestore()
            {
                // On termine l'operation d'ajout
                NativeMethods.RestorePointInfo rpInfo;
                NativeMethods.SystemManagerRestoreStatus rpStatus;

                rpInfo.dwEventType = EndSystemChange; //Type d'evenement : Fin d'operation.
                rpInfo.llSequenceNumber = rpSequenceNumber; // On indique l'index du dernier point.
                rpInfo.dwRestorePtType = 0; 
                rpInfo.szDescription = "";
                rpSequenceNumber = 0;
                return NativeMethods.SRSetRestorePointW(ref rpInfo, out rpStatus);
            }

        #endregion

    }

    #region Native Methods
    /// <summary>
    /// Classe utilisant l'api windows pour la gestion des points de restauration.
    /// </summary>
    internal class NativeMethods
    {

        // private constructor
        private NativeMethods() { }
        internal const Int16 DesktopSetting = 2;                    /* n'est pas implemente */
        internal const Int16 AccessibilitySetting = 3;              /* n'est pas implemente */
        internal const Int16 OeSetting = 4;                         /* n'est pas implemente */
        internal const Int16 ApplicationRun = 5;                    /* n'est pas implemente */
        internal const Int16 WindowsShutdown = 8;                   /* n'est pas implemente */
        internal const Int16 WindowsBoot = 9;                       /* n'est pas implemente */
        internal const Int16 MaxDesc = 64;
        internal const Int16 MaxDescW = 256;

        /// <summary>
        /// Informations du point de point de restauration.
        /// </summary>
        [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
        internal struct RestorePointInfo
        {
            internal int dwEventType;                                       // Type d'evenement.
            internal int dwRestorePtType;                                   // Type du point de Restauration.
            internal Int64 llSequenceNumber;                                // Nombre séquentielle pour le point de restauration (0 pour le début et fin d'operations).
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MaxDescW + 1)]
            internal string szDescription;                                  // Description
         }

        /// <summary>
        /// Etat retourne par le System Restore.
        /// </summary>
        [StructLayout(LayoutKind.Sequential)]
        internal struct SystemManagerRestoreStatus
        {
            internal int nStatus;                                   // Etat retournee par le State Manager Process
            internal Int64 llSequenceNumber;                        // Nombre séquentielle pour le point de restauration.
        }
        
        // API Native.
        [DllImport("srclient.dll")]
        [return : MarshalAs(UnmanagedType.Bool)]
        internal static extern bool SRSetRestorePointW(ref RestorePointInfo pRestorePtSpec, out SystemManagerRestoreStatus pSMgrStatus);

        [DllImport("srclient.dll")]
        internal static extern int SRRemoveRestorePoint(int dwRPNum);
    }

    #endregion
}

Conclusion :


Comme on dit precedement, l'application necessite les droit d'administrateur.ce probleme se pose sutout avec windows vista.
pour cela le manifest de l'assembly doit comporter une entree qui indique que l'application doit s'executer en mode administrateur.

voici le manifest

<?xml version="1.0" encoding="utf-8"?>
<asmv1:assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1" xmlns:asmv1="urn:schemas-microsoft-com:asm.v1" xmlns:asmv2="urn:schemas-microsoft-com:asm.v2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<assemblyIdentity version="1.0.0.0" name="MyApplication.app"/>
<trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
<security>
<requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3">
<!--Necessaire pour qu'elle s'execute sur windows vista-->
<requestedExecutionLevel level="requireAdministrator" uiAccess="false" />
</requestedPrivileges>
</security>
</trustInfo>
</asmv1:assembly>

Codes Sources

A voir également

Ajouter un commentaire Commentaires
Messages postés
78
Date d'inscription
dimanche 8 mai 2005
Statut
Membre
Dernière intervention
21 mars 2018
1
c le probleme de Microsoft de parametrer les points de restauration,

Mais pour moi, je la trouve tres interressante surtout apres les infections virales et les déordres
Messages postés
16
Date d'inscription
samedi 8 septembre 2007
Statut
Membre
Dernière intervention
27 avril 2009

patrice en meme temps la restauration systeme a pour but de récuperer exactement sont systeme en cas de virus, fausse manip ... donc sa sauvegarde tout.
Messages postés
1221
Date d'inscription
jeudi 23 août 2001
Statut
Membre
Dernière intervention
9 septembre 2018

Est-ce que l'on peut paramétrer le point de restauration ? Par exemple j'ai remarqué que la restauration système sauvegardait absolument n'importe quoi : mes dossiers perso. éparpillés au hasard sur mon dd, et les restaurait également au hasard en foutant un sacré bordel : du coup, la restauration système ne sert à rien du tout à mon avis, car elle cause plus de problème qu'elle n'en résout (à moins de faire une sauvegarde juste avant une installation hasardeuse) : si on pouvait demander à ne sauver que la base de registre et les dll système, ça serait à nouveau intéressant.

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.