elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


 


Tema destacado: Guía actualizada para evitar que un ransomware ataque tu empresa


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación General
| | |-+  .NET (C#, VB.NET, ASP) (Moderador: kub0x)
| | | |-+  [C#] Mover archivos de windows || Isolated Storage
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: [C#] Mover archivos de windows || Isolated Storage  (Leído 2,168 veces)
n-utz

Desconectado Desconectado

Mensajes: 165

Babylon es el vampiro!


Ver Perfil
[C#] Mover archivos de windows || Isolated Storage
« en: 22 Julio 2017, 05:32 »

Buenas gente, miren vengo con una idea que necesito que me orienten para poder hacerla.

La idea es esta >

Tengo varias 'resumenes' en txt que completo dia a dia en mi PC, y despues los voy copiando/reemplazando en la carpeta desktop de Google Drive, resulta que siempre reemplazo los mismos archivos, es decir mantengo actualizados mis resumenes de Google Drive y siempre son los mismos.

Se me ocurrio poder hacer algun programa (tengo la idea de .exe en la cabeza) que ejecute una macro o pedazo de codigo que mueva y reemplace los archivos de cierta carpeta/s a la de Google Drive y haga todo el proceso solo con tan solo ejecutar el .exe .

Por otro lado, estoy buscando información sobre como poder usar el Isolated Storage, no suelo entender la libreria de ms.

Si pueden orientarme en este asunto les agradezco, planeo hacerlo en VS 2017 con C#.


« Última modificación: 22 Julio 2017, 22:20 por n-utz » En línea

Eleкtro
Ex-Staff
*
Desconectado Desconectado

Mensajes: 9.709



Ver Perfil
Re: [C#] Mover archivos de windows || Isolated Storage
« Respuesta #1 en: 23 Julio 2017, 20:04 »

Hola.

Voy a empezar fuerte. Veamos...

Si quieres seguir mi consejo, entonces aquí debes plantearte el siguiente dilema (o al menos yo en tu lugar me lo plantearía muy seriamente):

- Si quieres crear una Macro, entonces usa cualquier herramienta para crear macros, no necesitas recurrir a un lenguaje de alto nivel como C#, de hecho lo que harías en 5 horas en C#, lo haces en 5 minutos con cualquier herramienta enfocada a las macros.
  Una herramienta excelente sería JitBit Macro Recorder.

- Si quieres usar C# para automatizar de forma programática la subida y sobreescirtura de archivos en Google Drive, entonces olvídate de crear macros, y usa la API de Google Drive para .NET, el resultado será un algoritmo informático optimizado en donde la subida/sobreescritura del archivo se realizaría en segundo plano o background, de forma asincrónica y resumible, y donde podrías controlar cualquier posible fallo/excepción al intentar subir/sobreescribir el archivo. Esta sofisticación, con una macro, requeriría mucho más esfuerzo y análisis en comparación para conseguir hacerlo... y hacerlo medianamente bien.
 
Si tu decisión final es seguir queriendo utilizar C# para desarrollar una macro, pues en mi humilde opinión eso que propones sería lo mismo que pretender estudiar la profesión de maquinista de trenes... sólo para usar trenes de juguete.



Es así, de verdad, para crear una macro en plan "automatizar pulsaciones del teclado y del ratón junto a análisis de comparación de imagen o automatización web" no necesitas C#, y de hecho el resultado no sería tan eficiente ( teniendo en cuenta que para empezar no sabes demasiado bien como hacerlo, y para eso deberías recurrir al aprendizaje de conceptos de software automation en .NET, o recurrir a metodologías rudimentarias con la WinAPI, lo que te llevaría mucho tiempo. ) en comparación con recurrir a una herramienta especializada en crear macros... como por ejemplo la herramienta que ya mencioné más arriba.



Partiendo de la premisa de arriba, y asumiendo que te hayas replanteado el problema para enfocarlo de forma óptima y utilizar C# junto a la API de Google Drive, entonces te explicaré el procedimiento...:

Antes de poder utilizar la API, primero existen unos pasos preeliminares que basicamente consisten en registrar una clave de la API de Google Drive para tu uso personal, con la que generar un archivo.json para poder realizar la autorización OAuthv2 en los servicios de Google Drive desde tu código/aplicación.

Aquí te explican paso a paso el qué y el cómo debes llevar a cabo el registro de la API:
...solo se toma de 5 o 10 minutos en hacerlo.

Step 1: Turn on the Drive API

    Use this wizard to create or select a project in the Google Developers Console and automatically turn on the API. Click Continue, then Go to credentials.
    On the Add credentials to your project page, click the Cancel button.
    At the top of the page, select the OAuth consent screen tab. Select an Email address, enter a Product name if not already set, and click the Save button.
    Select the Credentials tab, click the Create credentials button and select OAuth client ID.
    Select the application type Other, enter the name "Drive API Quickstart", and click the Create button.
    Click OK to dismiss the resulting dialog.
    Click the file_download (Download JSON) button to the right of the client ID.
    Move this file to your working directory and rename it client_secret.json.

Bien. El segundo paso sería descargar/instalar la API v3 de Google Drive para .NET:
( también necesitas descargar todas las dependencias que se indican al pie de página. )

Ten en cuenta que puedes automatizar la instalación de la API de Google Drive ( incluyendo sus dependencias ) en Visual Studio, simplemente creando un nuevo proyecto de C#, abriendo la consola de NuGet y escribiendo el siguiente comando en dicha consola:
Código:
Install-Package Google.Apis.Drive.v3

Llegados a este punto, ahora ya puedes empezar a desarrollar tu algoritmo con la API. Lo primero sería desarrollar una funcionalidad para la autentificación de usuario con la API de Google Drive, seguidamente otra funcionalidad para buscar/identificar el archivo que quieres sobreescribir, y por último implementar la funcionalidad para llevar a cabo la subida/sobreescritura del archivo.

...¿Que cómo se hace todo eso?, pues leyendo y poniendo en práctica todo lo leido, por supuesto, esto no es cosa de "hacer click y listo". Aquí tienes la documentación oficial de la API:


Esto es, mayórmente, sobre lo que debes documentarte:


PD: No es tan dificil como parece. Por si te sirve de ánimos: yo ya hice clientes en .NET con funcionalidades sincrónicas y asincónicas para administrar la cuenta de Youtube, Gmail, y Drive. Aprendido el manejo de uno, aprendidos todos xD, ya que las APIS de cada servicio de Google solo cambian en los nombres de sus miembros, pero su modo de empleo es practicamente idéntico...

Si tienes cualquier duda al respecto, no dudes en preguntar.

Saludos!


« Última modificación: 23 Julio 2017, 21:27 por Eleкtro » En línea


TickTack

Desconectado Desconectado

Mensajes: 263


Ver Perfil
Re: [C#] Mover archivos de windows || Isolated Storage
« Respuesta #2 en: 23 Julio 2017, 20:24 »

Hola Elektro,

desde el viernes que quize ayudar pero siempre hubo algo que no me dejo escribir una respuesta.

Yo crei que solo se trataba de mover archivos de una carpeta a otra.

Bueno pero antes de borrar mi codigo me gustaria publicarlo aqui (a menos que no este bien).

Envidiame, Elektro... jajaja. No. Si soy el peor... ni siquiera funciona:

Código:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace Pasador_de_archivos
{
    public partial class Form1 : Form
    {
        string carpetaorigen;
        string carpetadestino;

        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            foreach (string line in File.ReadLines(@"Datos.txt", Encoding.UTF8))
            {
                if(line.Contains("Origen"))
                {
                    carpetaorigen = line.Substring(8);
                }

                if(line.Contains("Destino"))
                {
                    carpetadestino = line.Substring(9);
                }
            }

            File.Move(carpetaorigen, carpetadestino);
        }
    }
}


Tambien queria comentar que para descargar archivos de Google Drive siempre me gusto este archivo.cs: https://gist.github.com/yasirkula/d0ec0c07b138748e5feaecbd93b6223c/archive/40ea0967c6e8e8ee3a3bb837d75be00f4400b4d5.zip

Saludos
En línea

Eleкtro
Ex-Staff
*
Desconectado Desconectado

Mensajes: 9.709



Ver Perfil
Re: [C#] Mover archivos de windows || Isolated Storage
« Respuesta #3 en: 23 Julio 2017, 20:38 »

Yo crei que solo se trataba de mover archivos de una carpeta a otra.

No sé, espero no haberme equivocado yo... por que de lo contrario estoy escribiendo mucho para nada xD. Lo que yo he interpretado es que el usuario pretende subir un archivo local, a una carpeta llamada "desktop" en su cuenta de Google Drive, y sobreescribir ese archivo existente por el archivo local. Como ya digo, espero no haberme equivocado yo xD.



( Me tomo la libertad de hacer doble post, por que el código de este comentario no cabe en el de arriba. )

No suelo entregarle el trabajo hecho a nadie, sino las herramientas para hacerlo, pero entiendo que hablar de APIs de terceros (y más siendo tan "completas" o extensas como las de Google) es sinónimo de pereza y dificultad... basicamente por que hay que aprender muy bien como funciona "internamente" para poder hacer algo con esa API.

Bueno, pues voy a intentar ayudarte un poco más en ese aspecto compartiendo contigo (y con los demás a los que les pueda resultar útil) un código que he extraido de mi framework comercial ElektroKit, que si a alguien le interesa... lo puede encontrar en mi firma de usuario.
El código original lo he recortado mucho solamente para dejar los miembros/funcionalidades que tú necesitarías para reproducir esa "macro", es decir la funcionalidad de autorización, la de identificar el archivo a sobreescribir, y la de sobreescribirlo.

EDITO: Lo he tenido que recortar muchísimo más de lo que esperaba para que quepa. Maldito límite de 30.000 caracteres XD.

Bueno, aquí lo tienes:

Código
  1. #Region " Google Drive Scopes "
  2.  
  3. Namespace Google.Drive.Enums
  4.  
  5.    ''' <summary>
  6.    ''' Specifies the OAuthv2 scopes for use with the Google Drive API.
  7.    ''' </summary>
  8.    <Flags>
  9.    Public Enum DriveScopes As Integer
  10.  
  11.        ''' <summary>
  12.        ''' View and manage the files in your Google Drive.
  13.        ''' </summary>
  14.        Full = 2
  15.  
  16.        ''' <summary>
  17.        ''' View and manage its own configuration data in your Google Drive.
  18.        ''' </summary>
  19.        ApplicationData = 4
  20.  
  21.        ''' <summary>
  22.        ''' View and manage Google Drive files and folders that you have opened or created with this application.
  23.        ''' </summary>
  24.        Files = 8
  25.  
  26.        ''' <summary>
  27.        ''' View and manage metadata of files in your Google Drive.
  28.        ''' </summary>
  29.        Metadata = 16
  30.  
  31.        ''' <summary>
  32.        ''' Modify your Google Apps Script scripts' behavior.
  33.        ''' </summary>
  34.        Scripts = 32
  35.  
  36.        ''' <summary>
  37.        ''' View the files in your Google Drive.
  38.        ''' </summary>
  39.        [ReadOnly] = 64
  40.  
  41.        ''' <summary>
  42.        ''' View metadata for files in your Google Drive.
  43.        ''' </summary>
  44.        MetadataReadonly = 128
  45.  
  46.        ''' <summary>
  47.        ''' View the photos, videos and albums in your Google Photos.
  48.        ''' </summary>
  49.        PhotosReadonly = 256
  50.  
  51.    End Enum
  52.  
  53. End Namespace
  54.  
  55. #End Region

+

Código
  1. #Region " Option Statements "
  2.  
  3. Option Strict On
  4. Option Explicit On
  5. Option Infer Off
  6.  
  7. #End Region
  8.  
  9. #Region " Imports "
  10.  
  11. Imports Google.Apis.Auth.OAuth2
  12. Imports Google.Apis.Drive.v3
  13. Imports Google.Apis.Drive.v3.Data
  14. Imports Google.Apis.Services
  15. Imports Google.Apis.Upload
  16. Imports Google.Apis.Util.Store
  17.  
  18. Imports Google.Drive.Enums
  19.  
  20. #End Region
  21.  
  22. #Region " Google Drive Client "
  23.  
  24. Namespace Google.Drive.Types
  25.  
  26.    ''' ----------------------------------------------------------------------------------------------------
  27.    ''' <summary>
  28.    ''' A client for Google Drive service.
  29.    ''' </summary>
  30.    ''' ----------------------------------------------------------------------------------------------------
  31.    Public NotInheritable Class DriveClient : Implements IDisposable
  32.  
  33. #Region " Private Fields "
  34.  
  35.        Private client As DriveService
  36.        Private credential As UserCredential
  37.        Private ReadOnly authExceptionMessage As String =
  38.            "The user has not yet authorized the usage of this application.
  39.             Call 'DriveClient.Authorize()' or 'DriveClient.AuthorizeAsync()' methods."
  40.        Private scopeDict As New Dictionary(Of DriveScopes, String)(StringComparison.Ordinal) From
  41.        {
  42.            {DriveScopes.Full, DriveService.Scope.Drive},
  43.            {DriveScopes.ApplicationData, DriveService.Scope.DriveAppdata},
  44.            {DriveScopes.Files, DriveService.Scope.DriveFile},
  45.            {DriveScopes.Metadata, DriveService.Scope.DriveMetadata},
  46.            {DriveScopes.MetadataReadonly, DriveService.Scope.DriveMetadataReadonly},
  47.            {DriveScopes.PhotosReadonly, DriveService.Scope.DrivePhotosReadonly},
  48.            {DriveScopes.ReadOnly, DriveService.Scope.DriveReadonly},
  49.            {DriveScopes.Scripts, DriveService.Scope.DriveScripts}
  50.        }
  51.  
  52. #End Region
  53.  
  54. #Region " Properties "
  55.  
  56.        ''' <summary>
  57.        ''' Gets the client credentials.
  58.        ''' </summary>
  59.        Public ReadOnly Property Secrets As ClientSecrets
  60.  
  61.        ''' <summary>
  62.        ''' Gets the mail address to authorize Drive service. (e.g: "mail@gmail.com")
  63.        ''' </summary>
  64.        Public ReadOnly Property MailAddress As String
  65.  
  66.        ''' <summary>
  67.        ''' Gets the current Drive OAuthv2 scopes.
  68.        ''' </summary>
  69.        Public ReadOnly Property Scopes As DriveScopes
  70.  
  71.        ''' <summary>
  72.        ''' Gets a value that determines whether Google Drive API authorization was done.
  73.        ''' </summary>
  74.        Public ReadOnly Property IsAuthorized As Boolean
  75.            Get
  76.                Return isAuthorizedB
  77.            End Get
  78.        End Property
  79.        Private isAuthorizedB As Boolean = False
  80.  
  81. #End Region
  82.  
  83. #Region " Constructors "
  84.  
  85.        Private Sub New()
  86.        End Sub
  87.  
  88.        ''' <param name="apiFile">
  89.        ''' The <c>client_secrets.json</c> file generated by Drive API console that contains the OAuthv2 login data
  90.        ''' such as the client id, client secret, and redirection URI.
  91.        ''' </param>
  92.        ''' <param name="mailAddress">
  93.        ''' The mail address to authorize Drive service. (e.g: "mail@gmail.com")
  94.        ''' </param>
  95.        ''' <param name="scopes">
  96.        ''' The Drive OAuthv2 scope.
  97.        ''' </param>
  98.        Public Sub New(apiFile As FileInfo, mailAddress As String, scopes As DriveScopes)
  99.            Me.MailAddress = mailAddress
  100.            Me.Scopes = scopes
  101.            Using sr As FileStream = apiFile.OpenRead()
  102.                Me.Secrets = GoogleClientSecrets.Load(sr).Secrets
  103.            End Using
  104.        End Sub
  105.  
  106. #End Region
  107.  
  108. #Region " Public Methods "
  109.  
  110. #Region " Authorization "
  111.  
  112.        ''' <summary>
  113.        ''' Authorizes this instance to use Google Drive API services.
  114.        ''' </summary>
  115.        ''' <example>
  116.        ''' <code>
  117.        ''' Dim client As New DriveClient("C:\secrets.json", "mail@gmail.com", DriveScopes.Full)
  118.        ''' Dim credential As UserCredential = client.Authorize()
  119.        ''' </code>
  120.        ''' </example>
  121.        Public Function Authorize() As UserCredential
  122.            Dim t As Task(Of UserCredential) = Task.Run(AddressOf Me.AuthorizeAsync)
  123.            t.Wait(Timeout.Infinite)
  124.            Return t.Result
  125.        End Function
  126.  
  127.        ''' <summary>
  128.        ''' Authorizes this instance to use Google Drive API services.
  129.        ''' </summary>
  130.        ''' <example>
  131.        ''' <code>
  132.        ''' Dim client As New DriveClient("C:\secrets.json", "mail@gmail.com", DriveScopes.Full)
  133.        ''' Dim credential As UserCredential = Await client.AuthorizeAsync()
  134.        ''' </code>
  135.        ''' </example>
  136.        Public Async Function AuthorizeAsync() As Task(Of UserCredential)
  137.            Dim scopeUrls As String() = GetScopeUrls(Scopes)
  138.  
  139.            Me.credential =
  140.                 Await GoogleWebAuthorizationBroker.AuthorizeAsync(Secrets,
  141.                                                                   scopeUrls.ToArray(),
  142.                                                                   MailAddress,
  143.                                                                   CancellationToken.None,
  144.                                                                   New FileDataStore("UNET", fullPath:=False))
  145.  
  146.            Me.client = New DriveService(New BaseClientService.Initializer() With {
  147.                                         .HttpClientInitializer = Me.credential,
  148.                                         .ApplicationName = "UNET" ', .ApiKey = ""
  149.            })
  150.  
  151.            isAuthorizedB = True
  152.            Return Me.credential
  153.        End Function
  154.  
  155. #End Region
  156.  
  157. #Region " Get Files "
  158.  
  159.        ''' <summary>
  160.        ''' Gets all the files stored in the current user account.
  161.        ''' </summary>
  162.        ''' <example>
  163.        ''' <code>
  164.        '''     Dim client As New DriveClient("C:\secrets.json", "mail@gmail.com", DriveScopes.Full)
  165.        '''     Dim credential As UserCredential = client.Authorize()
  166.        '''     Dim files As List(Of File) = client.GetFiles()
  167.        '''
  168.        '''     For Each file As File In files
  169.        '''         Dim sb As New StringBuilder
  170.        '''         With sb
  171.        '''             .AppendLine(String.Format("Id: {0}", file.Id))
  172.        '''             .AppendLine(String.Format("Owned By Me?: {0}", file.OwnedByMe))
  173.        '''             .AppendLine(String.Format("Name: {0}", file.Name))
  174.        '''         End With
  175.        '''         Console.WriteLine(sb.ToString)
  176.        '''     Next file
  177.        ''' </code>
  178.        ''' </example>
  179.        Public Function GetFiles() As List(Of File)
  180.            If Not (isAuthorizedB) Then
  181.                Throw New InvalidOperationException(authExceptionMessage)
  182.  
  183.            Else
  184.                Dim t As Task(Of List(Of File)) = Task.Run(AddressOf GetFilesAsync)
  185.                t.Wait(Timeout.Infinite)
  186.                Return t.Result
  187.  
  188.            End If
  189.        End Function
  190.  
  191.        ''' <summary>
  192.        ''' Asynchronously gets all the files stored in the current user account.
  193.        ''' </summary>
  194.        ''' <example>
  195.        ''' <code>
  196.        '''     Dim client As New DriveClient("C:\secrets.json", "mail@gmail.com", DriveScopes.Full)
  197.        '''     Dim credential As UserCredential = Await client.AuthorizeAsync()
  198.        '''     Dim files As List(Of File) = Await client.GetFilesAsync()
  199.        '''
  200.        '''     For Each file As File In files
  201.        '''         Dim sb As New StringBuilder
  202.        '''         With sb
  203.        '''             .AppendLine(String.Format("Id: {0}", file.Id))
  204.        '''             .AppendLine(String.Format("Owned By Me?: {0}", file.OwnedByMe))
  205.        '''             .AppendLine(String.Format("Name: {0}", file.Name))
  206.        '''         End With
  207.        '''         Console.WriteLine(sb.ToString)
  208.        '''     Next file
  209.        ''' </code>
  210.        ''' </example>
  211.        Public Async Function GetFilesAsync() As Task(Of List(Of File))
  212.  
  213.            If Not (isAuthorizedB) Then
  214.                Throw New InvalidOperationException(authExceptionMessage)
  215.  
  216.            Else
  217.                Dim request As FilesResource.ListRequest = Me.client.Files.List()
  218.                With request
  219.                    .PageSize = 100
  220.                    .IncludeTeamDriveItems = False
  221.                    .SupportsTeamDrives = False
  222.                    .Fields = "nextPageToken, files"
  223.                    .Q = "not mimeType contains 'folder'"
  224.                End With
  225.  
  226.                Dim response As FileList = Await request.ExecuteAsync()
  227.  
  228.                Dim files As New List(Of File)
  229.                Do While True
  230.  
  231.                    For Each file As File In response.Files
  232.                        Dim getRequest As FilesResource.GetRequest = Me.client.Files.Get(file.Id)
  233.                        With getRequest
  234.                            .SupportsTeamDrives = False
  235.                            .Fields = "*"
  236.                        End With
  237.  
  238.                        Dim getResponse As File = Await getRequest.ExecuteAsync()
  239.                        getRequest.AcknowledgeAbuse = True
  240.                        files.Add(getResponse)
  241.                    Next file
  242.  
  243.                    If Not String.IsNullOrEmpty(response.NextPageToken) Then
  244.                        request.PageToken = response.NextPageToken
  245.                        response = Await request.ExecuteAsync()
  246.                    Else
  247.                        Exit Do
  248.                    End If
  249.  
  250.                Loop
  251.  
  252.                Return files
  253.  
  254.            End If
  255.  
  256.        End Function
  257.  
  258.        ''' <summary>
  259.        ''' Asynchronously gets the files stored in the current user account that matches the specified search criteria.
  260.        ''' </summary>
  261.        ''' <example>
  262.        ''' <code>
  263.        '''     Dim client As New DriveClient("C:\secrets.json", "mail@gmail.com", DriveScopes.Full)
  264.        '''     Dim credential As UserCredential = Await client.AuthorizeAsync()
  265.        '''     Dim predicate As Func(Of File, Boolean) =
  266.        '''         Function(f As File) f.Name.Equals("My Folder Name", StringComparison.OrdinalIgnoreCase)
  267.        '''     Dim files As List(Of File) = Await client.GetFilesAsync(predicate)
  268.        '''
  269.        '''     For Each file As File In files
  270.        '''         Dim sb As New StringBuilder
  271.        '''         With sb
  272.        '''             .AppendLine(String.Format("Id: {0}", file.Id))
  273.        '''             .AppendLine(String.Format("Name: {0}", file.Name))
  274.        '''         End With
  275.        '''         Console.WriteLine(sb.ToString)
  276.        '''     Next file
  277.        ''' </code>
  278.        ''' </example>
  279.        Public Async Function GetFilesAsync(predicate As Func(Of File, Boolean)) As Task(Of List(Of File))
  280.            Dim folders As List(Of File) = Await GetFilesAsync()
  281.            Return folders.Where(predicate).ToList()
  282.        End Function
  283.  
  284.        ''' <summary>
  285.        ''' Gets a file stored in the current user account that matches the specified file id.
  286.        ''' </summary>
  287.        ''' <example>
  288.        ''' <code>
  289.        '''     Dim client As New DriveClient("C:\secrets.json", "mail@gmail.com", DriveScopes.Full)
  290.        '''     Dim credential As UserCredential = client.Authorize()
  291.        '''     Dim file As File) = client.GetFileById(" File Id. ")
  292.        '''
  293.        '''     Dim sb As New StringBuilder
  294.        '''     With sb
  295.        '''          .AppendLine(String.Format("Id: {0}", file.Id))
  296.        '''          .AppendLine(String.Format("Owned By Me?: {0}", file.OwnedByMe))
  297.        '''          .AppendLine(String.Format("Name: {0}", file.Name))
  298.        '''     End With
  299.        '''     Console.WriteLine(sb.ToString)
  300.        ''' </code>
  301.        ''' </example>
  302.        Public Function GetFileById(id As String) As File
  303.            If Not (isAuthorizedB) Then
  304.                Throw New InvalidOperationException(authExceptionMessage)
  305.  
  306.            Else
  307.                Dim t As Task(Of File) = Task.Run(Function() GetFileByIdAsync(id))
  308.                t.Wait(Timeout.Infinite)
  309.                Return t.Result
  310.  
  311.            End If
  312.        End Function
  313.  
  314.        ''' <summary>
  315.        ''' Asynchronously gets a file stored in the current user account that matches the specified file id.
  316.        ''' </summary>
  317.        ''' <example>
  318.        ''' <code>
  319.        '''     Dim client As New DriveClient("C:\secrets.json", "mail@gmail.com", DriveScopes.Full)
  320.        '''     Dim credential As UserCredential = Await client.AuthorizeAsync()
  321.        '''     Dim file As File) = Await client.GetFileByIdAsync(" File Id. ")
  322.        '''
  323.        '''     Dim sb As New StringBuilder
  324.        '''     With sb
  325.        '''          .AppendLine(String.Format("Id: {0}", file.Id))
  326.        '''          .AppendLine(String.Format("Owned By Me?: {0}", file.OwnedByMe))
  327.        '''          .AppendLine(String.Format("Name: {0}", file.Name))
  328.        '''     End With
  329.        '''     Console.WriteLine(sb.ToString)
  330.        ''' </code>
  331.        ''' </example>
  332.        Public Async Function GetFileByIdAsync(id As String) As Task(Of File)
  333.            If Not (isAuthorizedB) Then
  334.                Throw New InvalidOperationException(authExceptionMessage)
  335.  
  336.            Else
  337.                Dim predicate As Func(Of File, Boolean) =
  338.                      Function(f As File) f.Id.Equals(id, StringComparison.OrdinalIgnoreCase)
  339.  
  340.                Dim result As List(Of File) = Await Task.Run(Function() GetFilesAsync(predicate))
  341.                Return result.DefaultIfEmpty(Nothing).SingleOrDefault()
  342.  
  343.            End If
  344.        End Function
  345.  
  346. #End Region
  347.  
  348. #Region " Update (replace) File "
  349.  
  350.        ''' <summary>
  351.        ''' Updates (replaces) a existing file in the specified folder.
  352.        ''' </summary>
  353.        ''' <example>
  354.        ''' <code>
  355.        ''' Private Sub UpdateFile()
  356.        '''
  357.        '''    Dim client As New DriveClient("C:\secrets.json", "mail@gmail.com", DriveScopes.Full)
  358.        '''    Dim credential As UserCredential = client.Authorize()
  359.        '''
  360.        '''    Dim srcFile As New FileInfo("C:\File.ext")
  361.        '''    Dim dstFile As File = client.GetFilesByName("File to update.ext").Single()
  362.        '''
  363.        '''    Dim result As KeyValuePair(Of Upload.ResumableUpload, File) =
  364.        '''        client.UpdateFile(srcFile, dstFile)
  365.        '''        
  366.        '''    Dim upload As ResumableUpload = result.Key
  367.        '''    
  368.        '''    Select Case upload.GetProgress().Status
  369.        '''    
  370.        '''        Case Upload.UploadStatus.Failed
  371.        '''            Console.WriteLine("Upload Failed.")
  372.        '''            ' ToDo: Retry/Resume Upload?:
  373.        '''            ' upload.Upload()
  374.        '''            ' upload.Resume()
  375.        '''            
  376.        '''        Case Upload.UploadStatus.Completed
  377.        '''            Dim dstFile As ResumableUpload = result.Value
  378.        '''            Dim sb As New StringBuilder
  379.        '''            With sb
  380.        '''                .AppendLine(String.Format("Id: {0}", dstFile.Id))
  381.        '''                .AppendLine(String.Format("Name: {0}", dstFile.Name))
  382.        '''            End With
  383.        '''        Console.WriteLine(sb.ToString)
  384.        '''        
  385.        '''    End Select
  386.        '''
  387.        ''' End Sub
  388.        ''' </code>
  389.        ''' </example>
  390.        ''' <param name="srcFile">
  391.        ''' The source file to upload.
  392.        ''' </param>
  393.        ''' <param name="dstFile">
  394.        ''' The metadata of the existing file being updated.
  395.        ''' </param>
  396.        Public Function UpdateFile(srcFile As FileInfo, dstFile As File) As KeyValuePair(Of ResumableUpload, File)
  397.            If Not (isAuthorizedB) Then
  398.                Throw New InvalidOperationException(authExceptionMessage)
  399.  
  400.            Else
  401.                Dim t As Task(Of KeyValuePair(Of ResumableUpload, File)) =
  402.                    Task.Run(Function() Me.UpdateFileAsync(srcFile, dstFile, Nothing, Nothing))
  403.                t.Wait(Timeout.Infinite)
  404.                Return t.Result
  405.  
  406.            End If
  407.        End Function
  408.  
  409.        ''' <summary>
  410.        ''' Updates (replaces) a existing file in the specified folder.
  411.        ''' </summary>
  412.        ''' <example>
  413.        ''' <code>
  414.        ''' Private Sub UpdateFile()
  415.        '''
  416.        '''    Dim client As New DriveClient("C:\secrets.json", "mail@gmail.com", DriveScopes.Full)
  417.        '''    Dim credential As UserCredential = client.Authorize()
  418.        '''
  419.        '''    Dim srcFile As New FileInfo("C:\File.ext")
  420.        '''
  421.        '''    Dim result As KeyValuePair(Of Upload.ResumableUpload, File) =
  422.        '''        client.UpdateFile(srcFile, "File Id")
  423.        '''        
  424.        '''    Dim upload As ResumableUpload = result.Key
  425.        '''    
  426.        '''    Select Case upload.GetProgress().Status
  427.        '''    
  428.        '''        Case Upload.UploadStatus.Failed
  429.        '''            Console.WriteLine("Upload Failed.")
  430.        '''            ' ToDo: Retry/Resume Upload?:
  431.        '''            ' upload.Upload()
  432.        '''            ' upload.Resume()
  433.        '''            
  434.        '''        Case Upload.UploadStatus.Completed
  435.        '''            Dim dstFile As ResumableUpload = result.Value
  436.        '''            Dim sb As New StringBuilder
  437.        '''            With sb
  438.        '''                .AppendLine(String.Format("Id: {0}", dstFile.Id))
  439.        '''                .AppendLine(String.Format("Name: {0}", dstFile.Name))
  440.        '''            End With
  441.        '''        Console.WriteLine(sb.ToString)
  442.        '''        
  443.        '''    End Select
  444.        '''
  445.        ''' End Sub
  446.        ''' </code>
  447.        ''' </example>
  448.        ''' <param name="srcFile">
  449.        ''' The source file to upload.
  450.        ''' </param>
  451.        ''' <param name="dstFileId">
  452.        ''' The identifier of the existing file being updated.
  453.        ''' </param>
  454.        Public Function UpdateFile(srcFile As FileInfo, dstFileId As String) As KeyValuePair(Of ResumableUpload, File)
  455.            If Not (isAuthorizedB) Then
  456.                Throw New InvalidOperationException(authExceptionMessage)
  457.  
  458.            Else
  459.                Dim dstFile As File = GetFileById(dstFileId)
  460.                If (dstFile Is Nothing) Then
  461.                    Throw New Exception(String.Format("File not found with the specified Id: {0}", dstFileId))
  462.                End If
  463.  
  464.                Dim t As Task(Of KeyValuePair(Of ResumableUpload, File)) =
  465.                    Task.Run(Function() Me.UpdateFileAsync(srcFile, dstFile, Nothing, Nothing))
  466.                t.Wait(Timeout.Infinite)
  467.                Return t.Result
  468.  
  469.            End If
  470.        End Function
  471.  
  472.        ''' <summary>
  473.        ''' Asynchronously updates (replaces) a existing file in the specified folder.
  474.        ''' </summary>
  475.        ''' <example>
  476.        ''' <code>
  477.        ''' Private Async Sub UpdateFile()
  478.        '''
  479.        '''    Dim client As New DriveClient("C:\secrets.json", "mail@gmail.com", DriveScopes.Full)
  480.        '''    Dim credential As UserCredential = Await client.AuthorizeAsync()
  481.        '''
  482.        '''    Dim srcFile As New FileInfo("C:\File.ext")
  483.        '''    Dim dstFile As File = client.GetFilesByName("File to update.ext").Single()
  484.        '''
  485.        '''    Dim result As KeyValuePair(Of Upload.ResumableUpload, File) =
  486.        '''        Await client.UpdateFileAsync(srcFile, dstFile, AddressOf Me.Upload_ProgressChanged, Nothing)
  487.        '''
  488.        '''     Dim sb As New StringBuilder
  489.        '''     With sb
  490.        '''         .AppendLine(String.Format("Id: {0}", result.Value.Id))
  491.        '''         .AppendLine(String.Format("Name: {0}", result.Value.Name))
  492.        '''     End With
  493.        '''     Console.WriteLine(sb.ToString)
  494.        '''
  495.        ''' End Sub
  496.        '''
  497.        ''' Public Sub Upload_ProgressChanged(e As Upload.IUploadProgress)
  498.        '''
  499.        '''     Select Case e.Status
  500.        '''
  501.        '''         Case Upload.UploadStatus.Uploading
  502.        '''             Console.WriteLine("Bytes sent: {0}", e.BytesSent)
  503.        '''
  504.        '''         Case Upload.UploadStatus.Completed
  505.        '''             Console.WriteLine("Upload completed.")
  506.        '''
  507.        '''         Case Upload.UploadStatus.Failed
  508.        '''             Console.WriteLine("Upload failed. Reason: {0}", e.Exception.Message)
  509.        '''
  510.        '''         Case Else
  511.        '''             ' Do Nothing.
  512.        '''
  513.        '''     End Select
  514.        '''
  515.        ''' End Sub
  516.        ''' </code>
  517.        ''' </example>
  518.        ''' <param name="srcFile">
  519.        ''' The source file to upload.
  520.        ''' </param>
  521.        ''' <param name="dstFile">
  522.        ''' The metadata of the existing file being updated.
  523.        ''' </param>
  524.        ''' <param name="progressHandler">
  525.        ''' A event handler that will receive progress changes of the upload operation.
  526.        ''' </param>
  527.        ''' <param name="cancellationToken">
  528.        ''' A cancellation token to cancel the upload operation.
  529.        ''' </param>
  530.        Public Async Function UpdateFileAsync(srcFile As FileInfo,
  531.                                              dstFile As File,
  532.                                              progressHandler As Action(Of IUploadProgress),
  533.                                              cancellationToken As CancellationToken) As Task(Of KeyValuePair(Of ResumableUpload, File))
  534.  
  535.            If Not (isAuthorizedB) Then
  536.                Throw New InvalidOperationException(authExceptionMessage)
  537.  
  538.            Else
  539.                Dim request As FilesResource.UpdateMediaUpload
  540.                Dim progress As IUploadProgress
  541.                Using stream As New FileStream(srcFile.FullName, FileMode.Open, FileAccess.Read, FileShare.Read)
  542.  
  543.                    Dim dstFileTemp As New File() With {
  544.                        .AppProperties = dstFile.AppProperties,
  545.                        .Name = srcFile.Name,
  546.                        .Description = dstFile.Description,
  547.                        .Kind = dstFile.Kind,
  548.                        .Properties = dstFile.Properties,
  549.                        .OriginalFilename = dstFile.OriginalFilename,
  550.                        .Trashed = dstFile.Trashed,
  551.                        .WritersCanShare = dstFile.WritersCanShare
  552.                    }
  553.  
  554.                    request = Me.client.Files.Update(dstFileTemp, dstFile.Id, stream, dstFile.MimeType)
  555.                    With request
  556.                        .AddParents = String.Join(",", dstFile.Parents)
  557.                        .ChunkSize = 262144
  558.                        .SupportsTeamDrives = False
  559.                        .Fields = "*"
  560.                    End With
  561.  
  562.                    AddHandler request.ProgressChanged, progressHandler
  563.                    progress = Await request.UploadAsync(cancellationToken)
  564.                    RemoveHandler request.ProgressChanged, progressHandler
  565.                End Using
  566.  
  567.                Dim response As File = request.ResponseBody
  568.                Return New KeyValuePair(Of ResumableUpload, File)(request, response)
  569.  
  570.            End If
  571.  
  572.        End Function
  573.  
  574.        ''' <summary>
  575.        ''' Asynchronously updates (replaces) a existing file in the specified folder.
  576.        ''' </summary>
  577.        ''' <example>
  578.        ''' <code>
  579.        ''' Private Async Sub UpdateFile()
  580.        '''
  581.        '''    Dim client As New DriveClient("C:\secrets.json", "mail@gmail.com", DriveScopes.Full)
  582.        '''    Dim credential As UserCredential = Await client.AuthorizeAsync()
  583.        '''
  584.        '''    Dim srcFile As New FileInfo("C:\File.ext")
  585.        '''
  586.        '''    Dim result As KeyValuePair(Of Upload.ResumableUpload, File) =
  587.        '''        Await client.UpdateFileAsync(srcFile, "File Id", AddressOf Me.Upload_ProgressChanged, Nothing)
  588.        '''
  589.        '''     Dim sb As New StringBuilder
  590.        '''     With sb
  591.        '''         .AppendLine(String.Format("Id: {0}", result.Value.Id))
  592.        '''         .AppendLine(String.Format("Name: {0}", result.Value.Name))
  593.        '''     End With
  594.        '''     Console.WriteLine(sb.ToString)
  595.        '''
  596.        ''' End Sub
  597.        '''
  598.        ''' Public Sub Upload_ProgressChanged(e As Upload.IUploadProgress)
  599.        '''
  600.        '''     Select Case e.Status
  601.        '''
  602.        '''
  603.        '''         Case Upload.UploadStatus.Uploading
  604.        '''             Console.WriteLine("Bytes sent: {0}", e.BytesSent)
  605.        '''
  606.        '''         Case Upload.UploadStatus.Completed
  607.        '''             Console.WriteLine("Upload completed.")
  608.        '''
  609.        '''         Case Upload.UploadStatus.Failed
  610.        '''             Console.WriteLine("Upload failed. Reason: {0}", e.Exception.Message)
  611.        '''
  612.        '''         Case Else
  613.        '''             ' Do Nothing.
  614.        '''
  615.        '''     End Select
  616.        '''
  617.        ''' End Sub
  618.        ''' </code>
  619.        ''' </example>
  620.        ''' <param name="srcFile">
  621.        ''' The source file to upload.
  622.        ''' </param>
  623.        ''' <param name="dstFileId">
  624.        ''' The identifier of the existing file being updated.
  625.        ''' </param>
  626.        ''' <param name="progressHandler">
  627.        ''' A event handler that will receive progress changes of the upload operation.
  628.        ''' </param>
  629.        ''' <param name="cancellationToken">
  630.        ''' A cancellation token to cancel the upload operation.
  631.        ''' </param>
  632.        Public Async Function UpdateFileAsync(srcFile As FileInfo,
  633.                                              dstFileId As String,
  634.                                              progressHandler As Action(Of IUploadProgress),
  635.                                              cancellationToken As CancellationToken) As Task(Of KeyValuePair(Of ResumableUpload, File))
  636.  
  637.            If Not (isAuthorizedB) Then
  638.                Throw New InvalidOperationException(authExceptionMessage)
  639.  
  640.            Else
  641.                Dim dstFile As File = Await GetFileByIdAsync(dstFileId)
  642.                If (dstFile Is Nothing) Then
  643.                    Throw New Exception(String.Format("File not found with the specified Id: {0}", dstFileId))
  644.                End If
  645.  
  646.                Return Await Me.UpdateFileAsync(srcFile, dstFile, progressHandler, cancellationToken)
  647.  
  648.            End If
  649.  
  650.        End Function
  651.  
  652. #End Region
  653.  
  654. #End Region
  655.  
  656. #Region " Private Methods "
  657.  
  658.        Private Function GetScopeUrls(scopes As DriveScopes) As String()
  659.  
  660.            Return (From scope As KeyValuePair(Of DriveScopes, String) In Me.scopeDict
  661.                    Where Scopes.HasFlag(scope.Key)
  662.                    Select scope.Value).ToArray()
  663.  
  664.        End Function
  665.  
  666. #End Region
  667.  
  668. #Region " IDisposable Implementation "
  669.  
  670.        Private isDisposed As Boolean = False
  671.  
  672.        Public Sub Dispose() Implements IDisposable.Dispose
  673.            Me.Dispose(isDisposing:=True)
  674.            GC.SuppressFinalize(obj:=Me)
  675.        End Sub
  676.  
  677.        Private Sub Dispose(isDisposing As Boolean)
  678.  
  679.            If (Not Me.isDisposed) AndAlso (isDisposing) Then
  680.  
  681.                If (Me.client IsNot Nothing) Then
  682.                    Me.client.Dispose()
  683.                    Me.client = Nothing
  684.                End If
  685.  
  686.            End If
  687.  
  688.            Me.isDisposed = True
  689.  
  690.        End Sub
  691.  
  692. #End Region
  693.  
  694.    End Class
  695.  
  696. End Namespace
  697.  
  698. #End Region





• ¿Qué necesito para usar el código de arriba?

Puedes copiar todo el código en un nuevo proyecto de VB.NET para generar una dll que puedes usar sin complicación desde C#, o bien puedes traducir todo el código a C# con cualquier herramienta online de conversión de código VB.NET a C#, como por ejemplo http://converter.telerik.com/ (ojo, no existe la herramienta perfecta, puede producir errores de compilación que necesitarían ser arreglados manuálmente.)

Como ya dije, no me gusta darle todo el trabajo hecho a nadie, pero al menos te doy varias opciones para hacerlo más sencillo :P.


• ¿Cómo utilizo el código de arriba para mis propósitos?

1. Usar la función Authorize / AuthorizeAsync para llevar a cabo la autorización OAuthv2 en Google Drive.

2. Usar la función GetFiles / GetFilesAsyncpara listar los archivos contenidos en tu GoogleDrive, para identificar el archivo que quieres sobreescribir. Dicha función devolverá una colección de objetos Google.Apis.Drive.v3.Data.File, y en la propiedad "File.Id" está expuesto el identificador de cada archivo devuelto. La intención de usar esta función será para obtener dicho identificador.

3. Usar la función UpdateFile / UpdateFileAsync para sobreescribir un archivo existente, pasándole el Id. del archivo (objeto "file") que obtuviste previamente.

Fin. En esencia es así de sencillo.

Si te fijas bien en el código fuente, podrás ver que para cada uno de las funciones escribí un ejemplo de código que demuestra el modo de empleo de cada una. No resulta dificil traducir esos pequeños códigos de ejemplo a C# si lo llegases a necesitar.

Tampoco es necesario que lo uses, simplemente puedes tomar ese código en VB.NET como un punto de partida que puedes reproducir en C#, y extenderlo a tus necesidades.

PD: Me gustaría pensar que este código le podrá servir de utilidad ...a quien sea. ^^

Un saludo!
« Última modificación: 24 Julio 2017, 04:51 por Eleкtro » En línea


TickTack

Desconectado Desconectado

Mensajes: 263


Ver Perfil
Re: [C#] Mover archivos de windows || Isolated Storage
« Respuesta #4 en: 23 Julio 2017, 20:44 »

WWWWWWWWWWWWWWWWWowwwwwwwwwwwwwwwww.....

Hasta a mi me podria servir esto en futuro.....

Gracias por tu aporte!!!

Impresionante lo que pusiste...
En línea

Eleкtro
Ex-Staff
*
Desconectado Desconectado

Mensajes: 9.709



Ver Perfil
Re: [C#] Mover archivos de windows || Isolated Storage
« Respuesta #5 en: 23 Julio 2017, 22:06 »

Hasta a mi me podria servir esto en futuro.....

Ojalá, aunque está muy recortado. Es versión "slim". :xD

Gracias por tu aporte!!!

Gracias a ti también por colaborar con tu código, aunque al parecer no te funciona, jeje.

En un principio no entiendo muy bien por qué buscas un archivo llamado "datos.txt" y que contenga lineas con el texto "Origen" y "Destino" dentro de ese archivo, pero bueno, creo que das a entender un formato similar a esto:

Datos.txt
Código:
Origen: C:\CarpetaOrigen1
Destino: C:\CarpetaDestino1

Origen: C:\CarpetaOrigen2
Destino: C:\CarpetaDestino2

Origen: C:\CarpetaOrigen3
Destino: C:\CarpetaDestino3
etc...

Pero luego haces una llamada a File.Move(), que además lo tienes colocado FUERA del ciclo, aparte, creo que es evidente por que no funciona eso de mover una carpeta como si fuese un archivo xD (en su lugar puedes usar el método Directory.Move(), que además puede mover archivos también).

Teniendo un archivo de texto con el formato de arriba, quizás lo que realmente querías hacer es algo así:

Código
  1. DirectoryInfo srcDir = null;
  2. DirectoryInfo dstDir = null;
  3.  
  4. foreach (string line in File.ReadLines(@".\datos.txt", Encoding.Default)) {
  5.    if (line.StartsWith("origen", StringComparison.OrdinalIgnoreCase)) {
  6.        srcDir = new DirectoryInfo(line.Substring(line.IndexOf(' ')));
  7.    }
  8.  
  9.    if (line.StartsWith("destino", StringComparison.OrdinalIgnoreCase)) {
  10.        dstDir = new DirectoryInfo(line.Substring(line.IndexOf(' ')));
  11.    }
  12.  
  13.    if ((srcDir != null) && (dstDir != null)) {
  14.        try {
  15.            if (!srcDir.Exists) {
  16.                throw new DirectoryNotFoundException(srcDir.FullName);
  17.            }
  18.  
  19.            if (!dstDir.Exists) {
  20.                dstDir.Create();
  21.            }
  22.            srcDir.MoveTo(Path.Combine(dstDir.FullName, srcDir.Name));
  23.  
  24.        } catch (Exception ex) {
  25.            throw;
  26.  
  27.        } finally {
  28.            srcDir = null;
  29.            dstDir = null;
  30.  
  31.        }
  32.  
  33.    }
  34.  
  35. }

Saludos!
« Última modificación: 23 Julio 2017, 22:13 por Eleкtro » En línea


TickTack

Desconectado Desconectado

Mensajes: 263


Ver Perfil
Re: [C#] Mover archivos de windows || Isolated Storage
« Respuesta #6 en: 23 Julio 2017, 22:17 »

Hola Elektro,

ahhh si!! Ese codigo que tienes ahi ese era necesario para mover carpetas...

Yo, pero lo que queria mostrar es como mover archivos.

El documento de textos, en realidad es:

Origen: C:\CarpetaOrigen1\archivo.txt
Destino: C:\CarpetaDestino1\archivo.txt

Origen: C:\CarpetaOrigen2\archivo.txt
Destino: C:\CarpetaDestino2\archivo.txt

Origen: C:\CarpetaOrigen3\archivo.txt
Destino: C:\CarpetaDestino3\archivo.txt
etc...

Por eso use File.Move(). Tenia por entendido de que en el segundo parametro de ese metodo tambien tenia que ser pasado el nombre del archivo y su tipo como si ya existiese en la otra carpeta.....


Pero ves...

Ya publicaste otro codigo de como mover carpetas que tambien me podria servir en mis futuras operaciones de programas jejejej....


Muchas gracias
En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Ayuda. MOVER ARCHIVOS .TXT
Programación Visual Basic
xtrot 8 2,360 Último mensaje 11 Julio 2008, 23:51
por xtrot
Windows 2012 storage compartiendo archivos a OSX
Windows
Pedro_madrid 0 663 Último mensaje 7 Noviembre 2014, 10:54
por Pedro_madrid
Contar y mover Archivos con BAT
Scripting
naobradovich 3 2,990 Último mensaje 20 Agosto 2016, 02:12
por Eleкtro
Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines