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


 


Tema destacado: ¿Eres nuevo? ¿Tienes dudas acerca del funcionamiento de la comunidad? Lee las Reglas Generales


  Mostrar Mensajes
Páginas: 1 [2] 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 ... 1017
11  Foros Generales / Foro Libre / Re: foro foro.Comunidad Underground Hispana en: 22 Septiembre 2017, 15:05
Ese foro, http://foro.el-hacker.com/, en el que por cierto también aporté mi granito de arena como moderador, hace años que ya estaba condenado a la extinción por una gestión descuidada de sus administradores, en plural, por que a lo largo de los años fue pasando de mano en mano, de propietario a propietario... debido a que a ninguno le rentaba lo suficiente. Ya todo el mundo allí tanto el staff como los usuarios hace años que sabíamos que esta situación se iba a dar tarde o temprano... parecía algo inevitable, así que no es algo de extrañar. Era una buena comunidad, llena de buenas secciones, con gente social y agradable, pero la página no daba los suficientes beneficios.

Recuerdo que hace 2 o 3 meses me metí a ese foro a curiosear un poco, y vi un tema abierto por parte del actual Admin, donde éste explicaba lo mismo que yo acabo de explicar (no es nada nuevo ni estoy yo aquí contando secretos, insisto) y también comunicaba de forma pública su intención de cerrar el chiringito (es decir, de no seguir manteniendo el server). Supongo que eso es lo que ha sucedido con la página, que simplemente murió... de forma definitiva.

Saludos.
12  Programación / .NET / Re: ayuda con manejo de archivos en vb.net 2008 en: 22 Septiembre 2017, 13:39
Umm. no había pensado hacer eso. en verdad podría ser mas optimo , ya que con la solución que encontré tarda mucho.

La metodología propuesta por el compañero NEBIRE de obtener una colección con todos los tipos de archivos e ir filtrando según la extensión, tiene sus ventajas pero también sus desventajas, resultando así en una solución óptima en muchos casos, y en otros no. Todo depende del escenario / circunstancias donde vayas a aplicar esa (o cualquier otra) solución.



la solución que encontré tarda mucho.

Si el rendimiento (en general, como la velocidad de ejecución) es un factor de importancia para ti, entonces deberías utilizar un tipo de evaluación vaga (o Lazy Evaluation por su nombre en Inglés) como sería la interfáz IEnumerable, y hacer uso de la programación asincrónica o del paralelismo.

Voy a compartir contigo un pequeño extracto del código fuente de mi framework comercial ElektroKit (el cual se puede encontrar en mi firma de usuario del foro). Este código es una implementación personal (bueno, es un wrapper mejorado de la función Directory.GetFiles() ) de un buscador de archivos y directorios, aunque solo he dejado visible dos métodos en el código fuente para que puedas buscar archivos.

Aparte de los grandes beneficios en velocidad que podrás comprobar por ti miso en los tests aquí abajo del todo de este comentario, este buscador también soporta la característica de buscar por múltiples patrones de nombre y por múltiples patrones de extensiones al mismo tiempo, así como la capacidad de poder excluir sin miedo algunos cualquier directorio en el que el usuario no disponga de permisos de lectura (con la posibilidad adicional de lanzar una excepción de acceso no autorizado si así se desea hacer), cosa que con las funciones built-in de .NET Framework no se puede controlar de forma natural.

Simplemente copiar y pegar. Aquí tienes:

Código
  1. ' ***********************************************************************
  2. ' Author   : Elektro
  3. ' Modified : 14-November-2015
  4. ' ***********************************************************************
  5.  
  6. #Region " Option Statements "
  7.  
  8. Option Strict On
  9. Option Explicit On
  10. Option Infer Off
  11.  
  12. #End Region
  13.  
  14. #Region " Imports "
  15.  
  16. Imports System.Collections.Concurrent
  17. Imports System.IO
  18. Imports System.Linq
  19. Imports System.Security
  20. Imports System.Threading.Tasks
  21.  
  22. #End Region
  23.  
  24. #Region " ElektroKit.Core.IO.Tools.Files "
  25.  
  26. Namespace ElektroKit.Core.IO.Tools
  27.  
  28.    ''' ----------------------------------------------------------------------------------------------------
  29.    ''' <summary>
  30.    ''' Contains file related utilities.
  31.    ''' </summary>
  32.    ''' ----------------------------------------------------------------------------------------------------
  33.    Public NotInheritable Class Files
  34.  
  35. #Region " Constructors "
  36.  
  37.        ''' ----------------------------------------------------------------------------------------------------
  38.        ''' <summary>
  39.        ''' Prevents a default instance of the <see cref="Files"/> class from being created.
  40.        ''' </summary>
  41.        ''' ----------------------------------------------------------------------------------------------------
  42.        <DebuggerNonUserCode>
  43.        Private Sub New()
  44.        End Sub
  45.  
  46. #End Region
  47.  
  48. #Region " Public Methods "
  49.  
  50.        ''' ----------------------------------------------------------------------------------------------------
  51.        ''' <summary>
  52.        ''' Gets the files those matches the criteria inside the specified directory and/or sub-directories.
  53.        ''' </summary>
  54.        ''' ----------------------------------------------------------------------------------------------------
  55.        ''' <param name="dirPath">
  56.        ''' The root directory path to search for files.
  57.        ''' </param>
  58.        '''
  59.        ''' <param name="searchOption">
  60.        ''' The searching mode.
  61.        ''' </param>
  62.        '''
  63.        ''' <param name="fileNamePatterns">
  64.        ''' The file name pattern(s) to match.
  65.        ''' </param>
  66.        '''
  67.        ''' <param name="fileExtPatterns">
  68.        ''' The file extension pattern(s) to match.
  69.        ''' </param>
  70.        '''
  71.        ''' <param name="ignoreCase">
  72.        ''' If <see langword="True"/>, ignores the comparing case of <paramref name="fileNamePatterns"/> and <paramref name="fileExtPatterns"/> patterns.
  73.        ''' </param>
  74.        '''
  75.        ''' <param name="throwOnError">
  76.        ''' If set to <see langword="True"/>, exceptions will be thrown, like access denied to file or directory.
  77.        ''' </param>
  78.        ''' ----------------------------------------------------------------------------------------------------
  79.        ''' <returns>
  80.        ''' An <see cref="IEnumerable(Of FileInfo)"/> instance containing the files information.
  81.        ''' </returns>
  82.        ''' ----------------------------------------------------------------------------------------------------
  83.        ''' <exception cref="ArgumentException">dirPath or searchOption
  84.        ''' </exception>
  85.        ''' ----------------------------------------------------------------------------------------------------
  86.        <DebuggerStepThrough>
  87.        Friend Shared Function GetFiles(ByVal dirPath As String,
  88.                                        ByVal searchOption As SearchOption,
  89.                                        Optional ByVal fileNamePatterns As String() = Nothing,
  90.                                        Optional ByVal fileExtPatterns As String() = Nothing,
  91.                                        Optional ByVal ignoreCase As Boolean = True,
  92.                                        Optional ByVal throwOnError As Boolean = False) As IEnumerable(Of FileInfo)
  93.  
  94.            ' Analyze and resolve path problems. (eg. 'C:' -> 'C:\')
  95.            Files.AnalyzePath(dirPath)
  96.  
  97.            ' Analyze the passed arguments.
  98.            Files.AnalyzeArgs(dirPath, searchOption)
  99.  
  100.            ' Get and return the files.
  101.            Dim queue As New ConcurrentQueue(Of FileInfo)
  102.            Files.CollectFiles(queue, dirPath, searchOption, fileNamePatterns, fileExtPatterns, ignoreCase, throwOnError)
  103.            Return queue.AsEnumerable
  104.  
  105.        End Function
  106.  
  107.        ''' ----------------------------------------------------------------------------------------------------
  108.        ''' <summary>
  109.        ''' Gets the filepaths those matches the criteria inside the specified directory and/or sub-directories.
  110.        ''' </summary>
  111.        ''' ----------------------------------------------------------------------------------------------------
  112.        ''' <param name="dirPath">
  113.        ''' The root directory path to search for files.
  114.        ''' </param>
  115.        '''
  116.        ''' <param name="searchOption">
  117.        ''' The searching mode.
  118.        ''' </param>
  119.        '''
  120.        ''' <param name="fileNamePatterns">
  121.        ''' The file name pattern(s) to match.
  122.        ''' </param>
  123.        '''
  124.        ''' <param name="fileExtPatterns">
  125.        ''' The file extension pattern(s) to match.
  126.        ''' </param>
  127.        '''
  128.        ''' <param name="ignoreCase">
  129.        ''' If <see langword="True"/>, ignores the comparing case of <paramref name="fileNamePatterns"/> and <paramref name="fileExtPatterns"/> patterns.
  130.        ''' </param>
  131.        '''
  132.        ''' <param name="throwOnError">
  133.        ''' If set to <see langword="True"/>, exceptions will be thrown, like access denied to file or directory.
  134.        ''' </param>
  135.        ''' ----------------------------------------------------------------------------------------------------
  136.        ''' <returns>
  137.        ''' An <see cref="IEnumerable(Of String)"/> instance containing the filepaths.
  138.        ''' </returns>
  139.        ''' ----------------------------------------------------------------------------------------------------
  140.        ''' <exception cref="ArgumentException">dirPath or searchOption
  141.        ''' </exception>
  142.        ''' ----------------------------------------------------------------------------------------------------
  143.        <DebuggerStepThrough>
  144.        Friend Shared Function GetFilePaths(ByVal dirPath As String,
  145.                                            ByVal searchOption As SearchOption,
  146.                                            Optional ByVal fileNamePatterns As String() = Nothing,
  147.                                            Optional ByVal fileExtPatterns As String() = Nothing,
  148.                                            Optional ByVal ignoreCase As Boolean = True,
  149.                                            Optional ByVal throwOnError As Boolean = False) As IEnumerable(Of String)
  150.  
  151.            ' Analyze and resolve path problems. (eg. 'C:' -> 'C:\')
  152.            Files.AnalyzePath(dirPath)
  153.  
  154.            ' Analyze the passed arguments.
  155.            Files.AnalyzeArgs(dirPath, searchOption)
  156.  
  157.            ' Get and return the filepaths.
  158.            Dim queue As New ConcurrentQueue(Of String)
  159.            Files.CollectFilePaths(queue, dirPath, searchOption, fileNamePatterns, fileExtPatterns, ignoreCase, throwOnError)
  160.            Return queue.AsEnumerable
  161.  
  162.        End Function
  163.  
  164. #End Region
  165.  
  166. #Region " Private Methods "
  167.  
  168.        ''' ----------------------------------------------------------------------------------------------------
  169.        ''' <summary>
  170.        ''' Analyzes a directory path and perform specific changes on it.
  171.        ''' </summary>
  172.        ''' ----------------------------------------------------------------------------------------------------
  173.        ''' <param name="refDirPath">
  174.        ''' The directory path.
  175.        ''' </param>
  176.        ''' ----------------------------------------------------------------------------------------------------
  177.        ''' <exception cref="ArgumentNullException">dirPath;Value is null, empty, or white-spaced.
  178.        ''' </exception>
  179.        ''' ----------------------------------------------------------------------------------------------------
  180.        <DebuggerStepThrough>
  181.        Private Shared Sub AnalyzePath(ByRef refDirPath As String)
  182.  
  183.            If String.IsNullOrEmpty(refDirPath) OrElse String.IsNullOrWhiteSpace(refDirPath) Then
  184.                Throw New ArgumentNullException("dirPath", "Value is null, empty, or white-spaced.")
  185.  
  186.            Else
  187.                ' Trim unwanted characters.
  188.                refDirPath = refDirPath.TrimStart({" "c}).TrimEnd({" "c})
  189.  
  190.                If Path.IsPathRooted(refDirPath) Then
  191.                    ' The root paths contained on the returned FileInfo objects will start with the same string-case as this root path.
  192.                    ' So just for a little visual improvement, I'll treat this root path as a Drive-Letter and I convert it to UpperCase.
  193.                    refDirPath = Char.ToUpper(refDirPath.First()) & refDirPath.Substring(1)
  194.                End If
  195.  
  196.                If Not refDirPath.EndsWith("\"c) Then
  197.                    ' Possibly its a drive letter without backslash ('C:') or else just a normal path without backslash ('C\Dir').
  198.                    ' In any case, fix the ending backslash.
  199.                    refDirPath = refDirPath.Insert(refDirPath.Length, "\"c)
  200.                End If
  201.  
  202.            End If
  203.  
  204.        End Sub
  205.  
  206.        ''' ----------------------------------------------------------------------------------------------------
  207.        ''' <summary>
  208.        ''' Analyzes the specified directory values.
  209.        ''' </summary>
  210.        ''' ----------------------------------------------------------------------------------------------------
  211.        ''' <param name="dirPath">
  212.        ''' The root directory path to search for files.
  213.        ''' </param>
  214.        '''
  215.        ''' <param name="searchOption">
  216.        ''' The searching mode.
  217.        ''' </param>
  218.        ''' ----------------------------------------------------------------------------------------------------
  219.        ''' <exception cref="ArgumentException">dirPath or searchOption
  220.        ''' </exception>
  221.        ''' ----------------------------------------------------------------------------------------------------
  222.        <DebuggerStepThrough>
  223.        Private Shared Sub AnalyzeArgs(ByVal dirPath As String, ByVal searchOption As SearchOption)
  224.  
  225.            If Not Directory.Exists(dirPath) Then
  226.                Throw New ArgumentException(String.Format("Directory doesn't exists: '{0}'", dirPath), "dirPath")
  227.  
  228.            ElseIf (searchOption <> SearchOption.TopDirectoryOnly) AndAlso (searchOption <> SearchOption.AllDirectories) Then
  229.                Throw New ArgumentException(String.Format("Value of '{0}' is not valid enumeration value.", CStr(searchOption)), "searchOption")
  230.  
  231.            End If
  232.  
  233.        End Sub
  234.  
  235.        ''' ----------------------------------------------------------------------------------------------------
  236.        ''' <summary>
  237.        ''' Tries to instance the by-reference <see cref="DirectoryInfo"/> object using the given directory path.
  238.        ''' </summary>
  239.        ''' ----------------------------------------------------------------------------------------------------
  240.        ''' <param name="dirPath">
  241.        ''' The directory path used to instance the by-reference <see cref="DirectoryInfo"/> object.
  242.        ''' </param>
  243.        '''
  244.        ''' <param name="refDirInfo">
  245.        ''' The by-reference <see cref="DirectoryInfo"/> object to instance it using the given directory path.
  246.        ''' </param>
  247.        '''
  248.        ''' <param name="throwOnError">
  249.        ''' If set to <see langword="True"/>, exceptions will be thrown, like access denied to directory.
  250.        ''' </param>
  251.        ''' ----------------------------------------------------------------------------------------------------
  252.        <DebuggerStepThrough>
  253.        Private Shared Sub SetupDirInfoObject(ByVal dirPath As String,
  254.                                              ByRef refDirInfo As DirectoryInfo,
  255.                                              ByVal throwOnError As Boolean)
  256.  
  257.            Try
  258.                refDirInfo = New DirectoryInfo(dirPath)
  259.  
  260.            Catch ex As Exception
  261.  
  262.                Select Case ex.GetType ' Handle or suppress exceptions by its type,
  263.  
  264.                    ' I've wrote different types just to feel free to extend this feature in the future.
  265.                    Case GetType(ArgumentNullException),
  266.                         GetType(ArgumentException),
  267.                         GetType(SecurityException),
  268.                         GetType(PathTooLongException),
  269.                         ex.GetType
  270.  
  271.                        If throwOnError Then
  272.                            Throw
  273.                        End If
  274.  
  275.                End Select
  276.  
  277.            End Try
  278.  
  279.        End Sub
  280.  
  281.        ''' ----------------------------------------------------------------------------------------------------
  282.        ''' <summary>
  283.        ''' Tries to instance the by-reference <paramref name="refCol"/> object using the given directory path.
  284.        ''' </summary>
  285.        ''' ----------------------------------------------------------------------------------------------------
  286.        ''' <typeparam name="A">
  287.        ''' The type of the <paramref name="refCol"/> object used to cast and fill the by-reference collection.
  288.        ''' </typeparam>
  289.        '''
  290.        ''' <param name="objectAction">
  291.        ''' The method to invoke, only for <see cref="FileInfo"/> or <see cref="DirectoryInfo"/> objects, this parameter can be <see langword="Nothing"/>.
  292.        ''' </param>
  293.        '''
  294.        ''' <param name="sharedAction">
  295.        ''' The method to invoke, only for filepaths or directorypaths, this parameter can be <see langword="Nothing"/>.
  296.        ''' </param>
  297.        '''
  298.        ''' <param name="dirPath">
  299.        ''' The directory path used to instance the by-reference <paramref name="refCol"/> object.
  300.        ''' </param>
  301.        '''
  302.        ''' <param name="searchPattern">
  303.        ''' The search pattern to list files or directories.
  304.        ''' </param>
  305.        '''
  306.        ''' <param name="refCol">
  307.        ''' The by-reference <see cref="IEnumerable(Of A)"/> object to instance it using the given directory path.
  308.        ''' </param>
  309.        '''
  310.        ''' <param name="throwOnError">
  311.        ''' If set to <see langword="True"/>, exceptions will be thrown, like access denied to file or directory.
  312.        ''' </param>
  313.        ''' ----------------------------------------------------------------------------------------------------
  314.        <DebuggerStepThrough>
  315.        Private Shared Sub SetupFileDirCollection(Of A)(ByVal objectAction As Func(Of String, SearchOption,
  316.                                                                                              IEnumerable(Of A)),
  317.                                                    ByVal sharedAction As Func(Of String, String,
  318.                                                                                          SearchOption,
  319.                                                                                          IEnumerable(Of A)),
  320.                                                    ByVal dirPath As String,
  321.                                                    ByVal searchPattern As String,
  322.                                                    ByRef refCol As IEnumerable(Of A),
  323.                                                    ByVal throwOnError As Boolean)
  324.  
  325.            Try
  326.                If objectAction IsNot Nothing Then
  327.                    refCol = objectAction.Invoke(searchPattern, SearchOption.TopDirectoryOnly)
  328.  
  329.                ElseIf sharedAction IsNot Nothing Then
  330.                    refCol = sharedAction.Invoke(dirPath, searchPattern, SearchOption.TopDirectoryOnly)
  331.  
  332.                Else
  333.                    Throw New ArgumentException("Any Action has been defined.")
  334.  
  335.                End If
  336.  
  337.            Catch ex As Exception
  338.  
  339.                Select Case ex.GetType ' Handle or suppress exceptions by its type,
  340.  
  341.                    ' I've wrote different types just to feel free to extend this feature in the future.
  342.                    Case GetType(UnauthorizedAccessException),
  343.                         GetType(DirectoryNotFoundException),
  344.                         ex.GetType
  345.  
  346.                        If throwOnError Then
  347.                            Throw
  348.                        End If
  349.  
  350.                End Select
  351.  
  352.            End Try
  353.  
  354.        End Sub
  355.  
  356.        ''' ----------------------------------------------------------------------------------------------------
  357.        ''' <summary>
  358.        ''' Determines whether at least one of the specified patterns matches the given value.
  359.        ''' </summary>
  360.        ''' ----------------------------------------------------------------------------------------------------
  361.        ''' <param name="value">
  362.        ''' The value, which can be a filename, file extension, direcrory path, or directory name.
  363.        ''' </param>
  364.        '''
  365.        ''' <param name="patterns">
  366.        ''' The patterns to match the given value.
  367.        ''' </param>
  368.        '''
  369.        ''' <param name="ignoreCase">
  370.        ''' If set to <see langword="True"/>, compares ignoring string-case rules.
  371.        ''' </param>
  372.        ''' ----------------------------------------------------------------------------------------------------
  373.        ''' <returns>
  374.        ''' <see langword="True"/> at least one of the specified patterns matches the given value; <see langword="False"/> otherwise.
  375.        ''' </returns>
  376.        ''' ----------------------------------------------------------------------------------------------------
  377.        <DebuggerStepThrough>
  378.        Private Shared Function IsMatchPattern(ByVal value As String,
  379.                                               ByVal patterns As IEnumerable(Of String),
  380.                                               ByVal ignoreCase As Boolean) As Boolean
  381.  
  382.            ' Iterate the filename pattern(s) to match each name pattern on the current name.
  383.            For Each pattern As String In patterns
  384.  
  385.                ' Supress consecuent conditionals if pattern its an asterisk.
  386.                If pattern.Equals("*", StringComparison.OrdinalIgnoreCase) Then
  387.                    Return True
  388.  
  389.                ElseIf ignoreCase Then ' Compare name ignoring string-case rules.
  390.                    If value.ToLower Like pattern.ToLower Then
  391.                        Return True
  392.                    End If
  393.  
  394.                Else ' Compare filename unignoring string-case rules.
  395.                    If value Like pattern Then
  396.                        Return True
  397.                    End If
  398.  
  399.                End If ' ignoreCase
  400.  
  401.            Next pattern
  402.  
  403.            Return False
  404.  
  405.        End Function
  406.  
  407.        ''' <summary>
  408.        ''' Runs the next collector tasks synchronouslly.
  409.        ''' </summary>
  410.        <DebuggerStepThrough>
  411.        Private Shared Sub RunNextTasks(Of T)(ByVal action As Action(Of ConcurrentQueue(Of T),
  412.                                                                     String,
  413.                                                                     SearchOption,
  414.                                                                     IEnumerable(Of String),
  415.                                                                     IEnumerable(Of String),
  416.                                                                     Boolean,
  417.                                                                     Boolean),
  418.                                              ByVal queue As ConcurrentQueue(Of T),
  419.                                              ByVal dirPath As String,
  420.                                              ByVal firstPatterns As IEnumerable(Of String),
  421.                                              ByVal secondPatterns As IEnumerable(Of String),
  422.                                              ByVal ignoreCase As Boolean,
  423.                                              ByVal throwOnError As Boolean)
  424.  
  425.            Try
  426.                Task.WaitAll(New DirectoryInfo(dirPath).
  427.                                 GetDirectories.
  428.                                 Select(Function(dir As DirectoryInfo)
  429.                                            Return Task.Factory.StartNew(Sub()
  430.                                                                             action.Invoke(queue,
  431.                                                                                           dir.FullName, SearchOption.AllDirectories,
  432.                                                                                           firstPatterns, secondPatterns,
  433.                                                                                           ignoreCase, throwOnError)
  434.                                                                         End Sub)
  435.                                        End Function).ToArray)
  436.  
  437.            Catch ex As Exception
  438.  
  439.                Select Case ex.GetType ' Handle or suppress exceptions by its type,
  440.  
  441.                    ' I've wrote different types just to feel free to extend this feature in the future.
  442.                    Case GetType(UnauthorizedAccessException),
  443.                         GetType(DirectoryNotFoundException),
  444.                         ex.GetType
  445.  
  446.                        If throwOnError Then
  447.                            Throw
  448.                        End If
  449.  
  450.                End Select
  451.  
  452.            End Try
  453.  
  454.        End Sub
  455.  
  456.        ''' <summary>
  457.        ''' Collects the files those matches the criteria inside the specified directory and/or sub-directories.
  458.        ''' </summary>
  459.        <DebuggerStepThrough>
  460.        Private Shared Sub CollectFiles(ByVal queue As ConcurrentQueue(Of FileInfo),
  461.                                        ByVal dirPath As String,
  462.                                        ByVal searchOption As SearchOption,
  463.                                        ByVal fileNamePatterns As IEnumerable(Of String),
  464.                                        ByVal fileExtPatterns As IEnumerable(Of String),
  465.                                        ByVal ignoreCase As Boolean,
  466.                                        ByVal throwOnError As Boolean)
  467.  
  468.            ' Initialize a FileInfo collection.
  469.            Dim fileInfoCol As IEnumerable(Of FileInfo) = Nothing
  470.  
  471.            ' Initialize a DirectoryInfo.
  472.            Dim dirInfo As DirectoryInfo = Nothing
  473.            SetupDirInfoObject(dirPath, dirInfo, throwOnError)
  474.  
  475.            If fileExtPatterns IsNot Nothing Then
  476.                ' Decrease time execution by searching for files that has extension.
  477.                SetupFileDirCollection(Of FileInfo)(AddressOf dirInfo.GetFiles, Nothing,
  478.                                                    dirInfo.FullName, "*.*", fileInfoCol, throwOnError)
  479.            Else
  480.                ' Search for all files.
  481.                SetupFileDirCollection(Of FileInfo)(AddressOf dirInfo.GetFiles, Nothing,
  482.                                                    dirInfo.FullName, "*", fileInfoCol, throwOnError)
  483.            End If
  484.  
  485.            ' If the fileInfoCol collection is not empty then...
  486.            If fileInfoCol IsNot Nothing Then
  487.  
  488.                ' Iterate the files.
  489.                For Each fInfo As FileInfo In fileInfoCol
  490.  
  491.                    ' Flag to determine whether a filename pattern is matched. Activated by default.
  492.                    Dim flagNamePattern As Boolean = True
  493.  
  494.                    ' Flag to determine whether a file extension pattern is matched. Activated by default.
  495.                    Dim flagExtPattern As Boolean = True
  496.  
  497.                    ' If filename patterns collection is not empty then...
  498.                    If fileNamePatterns IsNot Nothing Then
  499.                        flagNamePattern = IsMatchPattern(fInfo.Name, fileNamePatterns, ignoreCase)
  500.                    End If
  501.  
  502.                    ' If file extension patterns collection is not empty then...
  503.                    If fileExtPatterns IsNot Nothing Then
  504.                        flagExtPattern = IsMatchPattern(fInfo.Extension, fileExtPatterns, ignoreCase)
  505.                    End If
  506.  
  507.                    ' If fileName and also fileExtension patterns are matched then...
  508.                    If flagNamePattern AndAlso flagExtPattern Then
  509.                        queue.Enqueue(fInfo) ' Enqueue this FileInfo object.
  510.                    End If
  511.  
  512.                Next fInfo
  513.  
  514.            End If ' fileInfoCol IsNot Nothing
  515.  
  516.            ' If searchOption is recursive then...
  517.            If searchOption = SearchOption.AllDirectories Then
  518.                RunNextTasks(Of FileInfo)(AddressOf CollectFiles,
  519.                                          queue, dirInfo.FullName, fileNamePatterns, fileExtPatterns, ignoreCase, throwOnError)
  520.            End If
  521.  
  522.        End Sub
  523.  
  524.        ''' <summary>
  525.        ''' Collects the filepaths those matches the criteria inside the specified directory and/or sub-directories.
  526.        ''' </summary>
  527.        <DebuggerStepThrough>
  528.        Private Shared Sub CollectFilePaths(ByVal queue As ConcurrentQueue(Of String),
  529.                                            ByVal dirPath As String,
  530.                                            ByVal searchOption As SearchOption,
  531.                                            ByVal fileNamePatterns As IEnumerable(Of String),
  532.                                            ByVal fileExtPatterns As IEnumerable(Of String),
  533.                                            ByVal ignoreCase As Boolean,
  534.                                            ByVal throwOnError As Boolean)
  535.  
  536.            ' Initialize a filepath collection.
  537.            Dim filePathCol As IEnumerable(Of String) = Nothing
  538.  
  539.            If fileExtPatterns IsNot Nothing Then
  540.                ' Decrease time execution by searching for files that has extension.
  541.                SetupFileDirCollection(Of String)(Nothing, AddressOf Directory.GetFiles,
  542.                                                  dirPath, "*.*", filePathCol, throwOnError)
  543.            Else
  544.                ' Search for all files.
  545.                SetupFileDirCollection(Of String)(Nothing, AddressOf Directory.GetFiles,
  546.                                                  dirPath, "*", filePathCol, throwOnError)
  547.            End If
  548.  
  549.            ' If the filepath collection is not empty then...
  550.            If filePathCol IsNot Nothing Then
  551.  
  552.                ' Iterate the filepaths.
  553.                For Each filePath As String In filePathCol
  554.  
  555.                    ' Flag to determine whether a filename pattern is matched. Activated by default.
  556.                    Dim flagNamePattern As Boolean = True
  557.  
  558.                    ' Flag to determine whether a file extension pattern is matched. Activated by default.
  559.                    Dim flagExtPattern As Boolean = True
  560.  
  561.                    ' If filename patterns collection is not empty then...
  562.                    If fileNamePatterns IsNot Nothing Then
  563.                        flagNamePattern = IsMatchPattern(Path.GetFileNameWithoutExtension(filePath), fileNamePatterns, ignoreCase)
  564.                    End If
  565.  
  566.                    ' If file extension patterns collection is not empty then...
  567.                    If fileExtPatterns IsNot Nothing Then
  568.                        flagExtPattern = IsMatchPattern(Path.GetExtension(filePath), fileExtPatterns, ignoreCase)
  569.                    End If
  570.  
  571.                    ' If fileName and also fileExtension patterns are matched then...
  572.                    If flagNamePattern AndAlso flagExtPattern Then
  573.                        queue.Enqueue(filePath) ' Enqueue this filepath.
  574.                    End If
  575.  
  576.                Next filePath
  577.  
  578.            End If ' filePathCol IsNot Nothing
  579.  
  580.            ' If searchOption is recursive then...
  581.            If searchOption = SearchOption.AllDirectories Then
  582.                RunNextTasks(Of String)(AddressOf CollectFilePaths,
  583.                                        queue, dirPath, fileNamePatterns, fileExtPatterns, ignoreCase, throwOnError)
  584.            End If
  585.  
  586.        End Sub
  587.  
  588. #End Region
  589.  
  590.    End Class
  591.  
  592. End Namespace
  593.  
  594. #End Region
  595.  



Puedes testear la velocidad de mi función y compararlo con las funciones Directory.GetFiles() y My.Computer.FileSystem.GetFiles() mediante el siguiente código:

Código
  1. Imports System.Collections.ObjectModel
  2. Imports System.IO
  3.  
  4. Module Module1
  5.  
  6.    Sub Main()
  7.  
  8.        Dim dirPath As String = "C:\"
  9.  
  10.        Dim methodDirectoryGetFiles As String()
  11.        Dim methodMyComputerGetFiles As ReadOnlyCollection(Of String)
  12.        Dim methodElektroGetFiles As IEnumerable(Of String)
  13.        Dim sw As New Stopwatch()
  14.  
  15.        sw.Start()
  16.        methodDirectoryGetFiles = Directory.GetFiles(dirPath, "*", IO.SearchOption.AllDirectories)
  17.        sw.Stop()
  18.        Debug.WriteLine(String.Format("method DirectoryGetFiles  - Elapsed Time: {0}", sw.Elapsed.ToString("mm\:ss\:ffff")))
  19.  
  20.        sw.Reset()
  21.        sw.Start()
  22.        methodMyComputerGetFiles = My.Computer.FileSystem.GetFiles(dirPath, FileIO.SearchOption.SearchAllSubDirectories, "*")
  23.        sw.Stop()
  24.        Debug.WriteLine(String.Format("method MyComputerGetFiles - Elapsed Time: {0}", sw.Elapsed.ToString("mm\:ss\:ffff")))
  25.  
  26.        sw.Reset()
  27.        sw.Start()
  28.        methodElektroGetFiles = ElektroKit.Core.IO.Tools.Files.GetFilePaths(dirPath, IO.SearchOption.AllDirectories, Nothing, {"*"}, True, True)
  29.        sw.Stop()
  30.        Debug.WriteLine(String.Format("method ElektroGetFiles    - Elapsed Time: {0}", sw.Elapsed.ToString("mm\:ss\:ffff")))
  31.  
  32.    End Sub
  33.  
  34. End Module

Aquí tienes unos tests que he realizado:

Código:
Directorio: P:\
Patrón de búsqueda: "*"
Búsqueda recursiva: Sí
Cantidad de archivos a analizar: 142.880 y 7.374 carpetas
Tamaño total de los archivos: 238 Gigabytes
Tamaño por Colección/Array: 142.880 elementos
------------------------------------------------------------
method DirectoryGetFiles  - Elapsed Time: 00:01:4564 ++
method MyComputerGetFiles - Elapsed Time: 02:59:5497 +++
method ElektroGetFiles    - Elapsed Time: 00:00:5751 +

Código:
Directorio: G:\
Patrón de búsqueda: "*"
Búsqueda recursiva: Sí
Cantidad de archivos a analizar: 373.384 y 28.721 carpetas
Tamaño total de los archivos: 1.58 Terabytes
Tamaño por Colección/Array: 373.384 elementos
------------------------------------------------------------
method DirectoryGetFiles  - Elapsed Time: 00:04:5291 ++
method MyComputerGetFiles - Elapsed Time: 24:00:5846 +++ (si, eso han sido 24 ***** minutos los que ha tardado)
method ElektroGetFiles    - Elapsed Time: 00:01:7399 +

Código:
Directorio: C:\Windows\System32
Patrón de búsqueda: "*.dll"
Búsqueda recursiva: No
Cantidad de archivos a analizar: 3.465
Tamaño de archivos: 1.60 Gigabytes
Tamaño por Colección/Array: 2.620 elementos
------------------------------------------------------------
method DirectoryGetFiles  - Elapsed Time: 00:00:0138 +
method MyComputerGetFiles - Elapsed Time: 00:00:0608 +++
method ElektroGetFiles    - Elapsed Time: 00:00:0151 ++

Como puedes comprobar, mi implementación es altamente velóz cuanto mayor es la cantidad de archivos a analizar, y es casi igual de eficiente a la función Directory.GetFiles() cuando se trata de una cantidad pequeña de archivos a analizar, con una diferencia ínfima de milisegundos... lo que hace que merezca mucho la pena usarlo si necesitamos buscar varias extensiones de archivo al mismo tiempo.

Bueno, y de la función My.Computer.FileSystem.GetFiles mejor ni hablemos, los resultados hablan por si mismos. Los miembros expuestos en  "My.Computer" al igual que en Microsoft.VisualBasic están muy poco optimizados y ningún programador de VB.NET al que le preocupe el rendimiento de su app debería usarlos. De hecho en el foro he repetido mil veces que los miembros del namespace Microsoft.VisualBasic solo existen por temas de compatibilidad y conformidad por gente que migre de VB6 a VB.NET y lo tengan más facil para orientarse, que ningún programador de VB.NET debería utilizar el namespace Microsoft.VisualBasic más que para mostrar un MsgBox y listo xD, se creerán que hablo por hablar o algo... pues bueno, pueden ver por ustedes mismos el nefasto código fuente en la referencia online del source de .NET Framework.

PD: Estos tests se han realizado bajo circunstancias óptimas, realizando dos veces consecutivas cada llamada a cada uno de los tres métodos para que la caché de archivos enumerados del disco se actualizase y evitar así diferencias dispares en el tiempo de ejecución entre cada método.

Un saludo.
13  Programación / Programación General / Re: ¿Que es mejor? Un IDE o Compilador en: 22 Septiembre 2017, 11:25
Hola.

¿Que es mejor? Un IDE o Compilador

La pregunta carece de sentido puesto que un IDE o entorno de programación y un compilador son cosas diferentes, lo que ocurre es que la mayoría de IDEs hoy en día (sino todos) integran funcionalidades de compilación, pero que vayan en conjunto y cojidos de la mano no significa que sean lo mismo, un compilador es algo aparte, individual.

La definición de IDE (o en su defecto un editor de texto) se podría reducir a ser una herramienta para la escritura del código, y el compilador para compilar el código... como su propio nombre indica por si solo.

¿es mejor un IDE o usar un editor de texto y un compilador?.

Un editor de texto no es un IDE. Un editor de texto está enfocado a la edición de texto (o código) en general, mientras que un IDE es una herramienta especializada en el desarrollo de algoritmos programáticos mediante "X" lenguaje de programación. Creo que esto es suficiente para poder autoresponderse a la pregunta por uno mismo: ¿qué es mejor para programar, un IDE o un editor de texto?.

Hoy en día existen bastantes editores de texto "cómodos" que cumplen de forma superficial y parcialmente con algunas funcionalidades básicas de un IDE (ej. Sublime Text, Notepad++), entre ellas el resaltado de sintaxis, el autocompletado de miembros, el análisis sintáctico del código, y la compilación de código, y algunos otros también soportan la depuración de código (ej. Visual Studio Code, o los editores anteriormente mencionados... con ciertos plugins de terceros), pero no se les puede llamar IDE, sencillamente por que no lo son de forma completa, de lo contrario se llamarían IDE.

Algunos programadores de lenguajes de markups como HTML o XML y/o de algunos lenguajes de scripting como Python o Ruby los hay quienes prefieren usar un editor de texto (ej. Sublime Text) antes que un IDE especializado en dicho lenguaje de programación (ej. PyCharm, RubyMine), pero aquí no estamos cuestionando los gustos o el sentido de conformidad personal de cada individuo, sino qué tipo de herramienta es más óptima para llevar a cabo la tarea de programación. y para muchos lenguajes de programación el hecho de preferir usar un editor de texto antes que un IDE es sinónimo de haber adoptado malos hábitos de programación y ser altamente conformistas con una tipo de herramienta inferior al tipo de herramienta que realmente está destinada a beneficiarnos en tal propósito: un IDE. De hecho, para algunos lenguajes de programación de alto nivel resultaría absurdo intentar desarrollar una aplicación mediante un simple editor de texto... sencillamente sería de locos, por que se necesita al IDE para la automatización de ciertos procedimientos y la autogeneración de código en segundo plano que nos ahorraría el equivalente a estar varias horas (o dias, o semanas, según la embergadura del proyecto) escribiendo de forma manual el código en un editor de texto, y encima sin la posibilidad de poder depurarlo eficientemente en éste.

Por otro lado también hay que mencionar que existen muchas IDEs que son malas o al menos yo las considero malas (y esto por lo general también va acompañado a que sean IDEs gratuitas) tanto en la estética como en su intento por optimizar el rendimiento del usuario final. Las hay que son de todo excepto cómodas... y es que un IDE promete ser más óptimo, pero no más cómodo que un editor de texto ligero.

Un IDE profesional proporciona toda una amplia gama de características que no se verán en editor de texto (o un intento de IDE como Sublime Text o Notepad++), sin ir más lejos: algo tan necesario como es un diseñador de tipo WYSIWYG (what you see is what you get) de interfaces gráficas (o GUI builder por su nombre en Inglés), o un sistema sofisticado de depuración (mucho más que lo que tenga cualquier editor de texto), o algo de lo más básico como es el procedimiento inicial de creación de proyectos personalizados para un lenguaje específico (ej. una aplicación de consola, o una librería), o algo más avanzado como las herramientas de diagnóstico para la evaluación del consumo de memoria y rendimiento del CPU (conocido como Profilling por su nombre en Inglés), o funcionalidades de evaluación de unidades de código (o Unit Testing por su nombre en Inglés), o emuladores de dispositivos Android, o herramientas de automatización gráfica de la aplicación (conocido como Coded UI por su nombre en Inglés, aunque por el momento solo lo he visto disponible exclusivamente en el IDE Visual Studio), o herramientas de evaluación de la complejidad ciclomática de tu código, y así podriamos seguir hasta llenar la hoja entera de un cuaderno por delante y por detrás.

Un editor de texto no es un IDE, que eso nos quede claro. Si vas a programar de forma seria, entonces usa un IDE, pero si no necesitas las funcionalidades adicionales de un IDE y prefieres usar un editor de texto por que te sientes más...cómodo o simplemente por que te es suficiente para escribir pequeños códigos que no necesitan de tratamiento profesional en un IDE, pues hazlo a tu manera como tú prefieras, ya que al final en mi opinión lo único que importa es utilizar la herramienta que mejor nos consiga hacer optimizar nuestro tiempo y rendimiento.

Saludos.
14  Programación / .NET / Re: Aprender VB.NET O VB.6? en: 22 Septiembre 2017, 08:25
Hola.

hoy vengo a molestar preguntando cual de los 2 lenguajes es mejor, cual es mas optimo, etc.

Si esta pregunta hubiese sido formulada en el año 2002 todavía sería comprensible, pero en pleno año 2017 tras 19 años desde la muerte o descontinuación de VB6 y +15 años de desarrollo y evolución de la plataforma .NET Framework la verdad cuesta creer que siga existiendo dudas y desinformación entre las nuevas generaciones de programadores.

Puedes tomarte lo que acabo de decir como una respuesta a tus dudas. Visual Basic.NET es el sucesor y evolución directa de Visual Basic, no hay mucho más que añadir a este argumento de peso. Se podría explicar en profundidad todos los detalles y diferencias al respecto entre ambos lenguajes, pero toda la información necesaria la tienes al alcance de tu mano en la World Wide Web, la puedes buscar por ti mismo en Google...

Me he enterado que existen muchas versiones de VB.NET, pero cual elijo?

A la hora de elegir más bien no elijes una versión del lenguaje de forma individual, sino una versión de la IDE, y la respuesta a eso es muy simple: la versión más actual, es decir: Visual Studio 2017 / VB15.

Al momento de desarrollar código y de compilar una aplicación deberás tomar otro tipo de decisión: ¿qué versión de .NET Framework debo soportar?. Al igual que antes, cuanto más actual sea dicha versión más beneficios obtendrás en tu entorno de programación. La versión más actual es .NET Framework 4.7, pero para poder utilizarla necesitas estar bajo una release actual de Windows 10 (ya que la instalación de los targeting packs de .NET Framework 4.7 no son compatible con otros sistemas operativos ni tampoco con las primeras releases de Windows 10). Con que soportes la versión 4.5 o 4.6 de .NET Framework será más que suficiente para poder disfrutar de todas las mejoras actuales, sobre todo las mejoras de programación asincrónica con los keywords Async / Await.

Lo que en realidad debería preocuparte un poco es qué tecnología elegir para compilar tus aplicaciones y desempeñar los progresos de tu aprendizaje: Windows Forms, Windows Presentation Foundation, ASP.NET, etc. Mi recomendación para el desarrollo de aplicaciones de escritorio: WPF. Y si quieres desarrollar aplicaciones multiplataforma entonces deberás utilizar una versión reducida y portable de .NET Framework, conocida como: .NET Core.

Saludos.
15  Foros Generales / Noticias / Re: Bill Gates confiesa que se arrepiente de haber creado el CTRL+ALT+SUPR en: 21 Septiembre 2017, 21:27
como se nota que el señor Gates no limpia el teclado con el ordenador encendido  :silbar:

...y por lo que parece con el teclado activado también xD. ¿Va siendo hora de cambiarse a un teclado con botón de ON/OFF?, yo solo lo comento. :P

Saludos!
16  Foros Generales / Foro Libre / ¿Herramienta verificadora de e-mails gratuita? en: 21 Septiembre 2017, 08:20
Hola.

Esta pregunta trata sobre herramientas de e-mail marketing. Me gustaría saber si alguien conoce alguna aplicación para Windows que sea GRATUITA y certificada (es decir, con validaciones de confianza, sin falsos positivos) que permita verificar la existencia de direcciones de correo de grandes listas de cientos de millones de e-mails en formato .txt o .csv. Y a ser posible opcionálmente que sea capaz de identificar direcciones de trampas de Spam (spam traps por su nombre en Inglés).

¿Alguien sabe algo?.

Gracias por leer.
17  Programación / .NET / Re: actualizar access en: 21 Septiembre 2017, 04:08
como puedo hacer para que al leer un valor alfanumerico de un acces este se incremente en uno y se ponga en el excel?

Teniendo un patrón tal que: "Mi_Prefijo_0000"

1. Separar el String en dos partes o tokens, la alfabética (el prefijo), y la numérica (el índice).   "Mi_Prefijo_"  +  "0000"

2. Incrementar el valor de la parte numérica preservando la longitud del caracter de relleno, en este caso el Cero. ( ej. 0000 -> 0001 -> 0002 -> etc... )

3. Concatenar de nuevo la parte alfabética con la numérica, dando como resultado: "Mi_Prefijo_0001"

Fin.

No es algo complicado. Aquí tienes una función de uso genérico que he desarrollado la cual puedes adaptar a tus necesidades:

Código
  1. Public Shared Function IncrementIndexPattern(ByVal pattern As String, ByVal position As Integer, ByVal fillChar As Char) As String
  2.  
  3.    Dim curSuffix As String = pattern.Substring(position)
  4.    Dim newSuffix As String
  5.    Dim suffixLen As Integer = curSuffix.Length
  6.    Dim index As Integer
  7.  
  8.    If Not Integer.TryParse(If(fillChar = "0"c, curSuffix, curSuffix.TrimStart(fillChar)), index) Then
  9.        Throw New FormatException("The value does not have a valid numeric format.")
  10.    End If
  11.  
  12.    newSuffix = Convert.ToString(index + 1).PadLeft(suffixLen, fillChar)
  13.    If (newSuffix.Length > suffixLen) Then
  14.        ' -= Deposite su control de errores aquí =-
  15.        ' La longitud del nuevo índice es mayor que la capacidad de ceros.
  16.        ' Ej. "pattern_12345" es más largo que "pattern_000".
  17.        Throw New IndexOutOfRangeException()
  18.  
  19.    Else
  20.        Return pattern.Substring(0, position) & newSuffix
  21.  
  22.    End If
  23.  
  24. End Function

Ejemplo de uso:
Código
  1. ' Programatically building a pattern.
  2. Dim prefix As String = "My_Pattern_"
  3. Dim fillChar As Char = "#"c
  4. Dim fillCount As Integer = 4
  5. Dim firstIdx As String = New String(fillChar, (fillCount - 1)) & "0" ' ###0
  6. Dim pattern As String = (prefix & firstIdx) ' My_Pattern_###0
  7. Debug.WriteLine(pattern)
  8.  
  9. ' Setting the loop values.
  10. Dim idxStartPos As Integer = prefix.Length ' Or also: (pattern.LastIndexOf("_"c) + 1)
  11. Dim maxIndexCount As Integer = Convert.ToInt32(New String("9"c, fillCount)) ' Max possible index to fill.
  12.  
  13. For i As Integer = 0 To (maxIndexCount - 1)
  14.    pattern = IncrementIndexPattern(pattern, idxStartPos, fillChar)
  15.    Debug.WriteLine(pattern)
  16. Next i

Resultado de ejecución:
Código:
My_Pattern_###0
My_Pattern_###1
My_Pattern_###2
My_Pattern_###3
My_Pattern_###4
My_Pattern_###5
My_Pattern_###6
My_Pattern_###7
My_Pattern_###8
My_Pattern_###9
My_Pattern_##10
...
My_Pattern_9990
My_Pattern_9991
My_Pattern_9992
My_Pattern_9993
My_Pattern_9994
My_Pattern_9995
My_Pattern_9996
My_Pattern_9997
My_Pattern_9998
My_Pattern_9999

Saludos.
18  Programación / .NET / Re: ayuda con manejo de archivos en vb.net 2008 en: 21 Septiembre 2017, 02:41
Hola.

Yo el primer problema no lo entiendo, basicamente por que aquí ya estás utilizando una iteración recursiva en busca de archivos con distintas extensiones:


Así que en teoría eso ya sabes como resolverlo, pero bueno, te hago saber que la función System.IO.Directory.GetFiles() tiene una sobrecarga para que le indiques si la búsqueda debe realizarse de forma recursiva o no:


Dicho método no provee ninguna sobrecarga para especificar más de una extensión o patrón de búsqueda, para eso ya estabas utilizando la otra función, My.Computer.FileSystem.GetFiles().

Si quieres sustituir la función My.Computer.FileSystem.GetFiles() por System.IO.Directory.GetFiles() y conservando la funcionalidad de buscar varias extensiones, pues sí o sí tienes que llamar a dicha función más de una vez para concatenar los resultados en una colección. Ejemplo:

Código
  1. Dim dirPath As String = ".\"
  2. Dim fileExts As String() = {"*.vbs", "*.cmd", "*.js", "*.wsf", "*.ink", "*.bat"}
  3.  
  4. Dim filePaths As New List(Of String)
  5. For Each fileExt As String In fileExts
  6.    filePaths.AddRange(Directory.GetFiles(dirPath, String.Format("*.{0}", fileExt), SearchOption.AllDirectories))
  7. Next
  8.  
  9. For Each filePath As String In filePaths
  10.    Debug.WriteLine(filePath)
  11. Next



Código
  1. File.SetAttributes(dirPath, FileAttributes.Normal)

Eso es incorrecto, ya que así no solo estás eliminando el atributo Hidden, sino también todos los demás atributos que hayan sido asignados al archivo.

Tienes que conservar esos otros atributos. Ejemplo:

Código
  1. Dim filePath As String = "C:\file.txt"
  2. Dim attribs As FileAttributes = File.GetAttributes(filePath)
  3.  
  4. File.SetAttributes(filePath, attribs And Not FileAttributes.Hidden)




el code tiene que implementar la funcion de :
Código
  1. Dim dirPath As String = Form2.FolderBrowserDialog1.SelectedPath

para el directorio. no se si me entienden.  :silbar:

No, no lo entiendo bien. Supongo que te refieres a que quieres visualizar las carpetas ocultas en el árbol de carpetas de la ventana de diálogo FolderBrowserDialog, pues bien, eso no puedes hacerlo. El componente FolderBrowserDialog respeta la configuración del usuario, así que si el usuario no tiene activada la opción para ver archivos y carpetas ocultas, el componente no las mostrará.

De todas formas, una de las peores decisiones que un programador de .NET bajo tecnología WinForms puede tomar es utilizar el componente FolderBrowserDialog, ya que es límitadísimo y obsoleto, pues no le han modificado el diseño desde los 90. ¡Ni siquiera puedes introducir una ruta de directorio para navegar directamente!, no, tienes que clickar en los nodos hasta aburrirte. Es de lo peor, todo lo opuesto a productivo.



Por ese motivo te recomiendo encarecidamente que utilices los componentes gratuitos de Ooki, que son un wrapper de los diálogos modernos del "buscador" de carpetas:




PD: Insisto, ningún diálogo de carpetas te va a mostrar carpetas ocultas a menos que la opción de mostrar archivos y carpetas ocultas esté activada en el sistema. Puedes activarla tu mismo, aquí abajo te muestro como hacerlo, pero ten en cuenta que llevar a cabo este tipo de actos se considera intrusismo (un programa intrusivo):

Código
  1. Imports Microsoft.Win32

Código
  1. Using reg As RegistryKey = RegistryKey.OpenBaseKey(RegistryHive.CurrentUser, RegistryView.Default)
  2.    reg.OpenSubKey("Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced", writable:=True).
  3.        SetValue("Hidden", 1, RegistryValueKind.DWord)
  4. End Using

Saludos.
19  Foros Generales / Foro Libre / Re: Yoga. Una filosofía oriental, y un postureo occidental. en: 21 Septiembre 2017, 01:26
Bueno, Elektro, dejando de lado el debate, queria responder para agradecerte por el aporte, ya que siempre ayuda, y mas viendo el motivo por el cual has abierto este tema y por como van los temas relacionados con politica (entre otras cosas).  :D :) ;)

Saludos.

Gracias CrazyKenny. Tú siempre tan correcto, jeje :). El motivo de comprartir esos videos era que la gente se mentalizase del timo que existe con respecto al Yoga, pero que detrás del timo existe un arte ancestral cuya práctica es...honesta y sus fines éticos. A mi el señor del video me parece muy honrado.



Por eso venden las medicinas milagrosas, las píldoras que adelgazan, las que agradan el pene y mil timos mas. La gente quiere cosas sencillas, rápidas y sin esfuerzo

Y luego está esto otro...

http://www.elrellano.com/videos_online/13708/como-perder-peso-sin-dieta-ni-ejercicios.html

( no tiene desperdicio )

Saludos
20  Foros Generales / Noticias / Re: Dos años y medio de cárcel para un joven que instaló un sistema espía en el ... en: 20 Septiembre 2017, 13:33
Pues si mi pareja me hace eso, seguramente la denuncie. Que sea mi pareja y que yo sienta algo por ella no quiere decir que puede espiarme y meterse de pleno en mi vida privada. No la da derecho a estar las 24 horas encima mio ni mucho menos "sobreprotegerme".

Si no te gusta lo que hace tu pareja pues se lo dices y punto, para eso se supone que dos personas se juntan y forman una relación sentimental, para solucionar los conflictos mediante el díalogo, el Amor, respeto y comprensión, ¿no?. Si el celoso/desconfiado/espía no respeta a su pareja y no cesa en espiar pues cortas con él/ella y lo mandas a...tomar por saco, pero no vas y le denuncias sin pensar precisamente en las consecuencias de esa denuncia que acabará por arruinarle la vida y su futuro de negocio convirtiéndolo en un supuesto "criminal" ante cualquier futura entrevista de trabajo, por que entonces nunca has querido a esa persona.

No es un error cualquiera, es un abuso, y como tal, tiene sus consecuencias.

Es un error cualquiera, todo el mundo comete todo tipo de errores (cosas de las que luego se arrepiente) por Amor, desde la simple e inocente mentira piadosa para no herir los sentimientos de tu pareja (ej. "cariño, no se me ha olvidado nuestro aniversario, lo que ocurre es que... { deposite su excusa favorita aquí }"), hasta este tipo de errores que muchas veces no se llegan a cometer con maldad sino simplemente por miedo a perder a tu pareja, por sentirte inferior o que no te la mereces y se podría enamorar de otro, o cosas parecidas. La condena que ese tio se merece no es ir a la cárcel, sino ponerle a cargo de un profesional (psicólogo) para que reciba un poco de apoyo moral y recapacité sobre los actos que ha cometido ya está.

Esto no se puede llamar justicia lo mires por donde lo mires, me da igual si le instaló uno o cinco troyanos como si le pinchó el telefono a ella y a su abuela, esto es una injusticia, qué digo, ¡UNA VERGUENZA!, y la jueza esa es una hija de la grandísima PU... por que los problemas de este tipo son psicológicos, no vandálicos, y requieren que sean analizados como tal, como un problema mental de una persona que requiere AYUDA, no ser enjaulado en una celda para privarle de su libertad y "trastornarle" más de lo que ya lo está.
En mi opinión, aunque desde la ignorancia, la jueza al ser una mujer probablemente le faltó sentido de imparcialidad en sus observaciones, ya que la primera impresión que da todo este asunto es que ella no se puso en la piel del acusado, simplemente defendió los derechos de la mujer cual Feminazi y ale, a la cárcel, por que todos los hombres somos unos maltratadores en potencia y nos lo merecemos.  Pf. . .

Un error así no se merece unas consecuencias tan INMERECIDAS, para NADIE, ni para el hombre ni para la mujer que espíe, y mira que de ese tipo de mujeres celosas hay muchas más que hombres, todo el día cotilleando las conversaciones en el móvil y retorciéndose el cerebro pensando en cuantas veces les ponemos los cuernos con las amigas y hechándotelo en cara una y otra vez... ¿pero acaso algún hombre denuncia esas cosas?, ¿no verdad?, pues ya está.

En fin...
Páginas: 1 [2] 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 ... 1017
Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines