Etiqueta: truco

// Para tener en cuenta cuando no se lee el EXIF correctamente
// 
// Si es jpg en la función lee los datos EXIF pero al devolverlo está vacío,
// así que usaremos el último exif leído a ver si es el mismo nombre

private BitmapMetadata? ultimoExif = null;
private string ultimoFicExif = "";

private DateTime FechaExif(FileInfo fi)
{
    DateTime fechaFic;
    var ficEXIF = InfoFoto(fi.FullName);
    if (ficEXIF == null || string.IsNullOrEmpty(ficEXIF.DateTaken))
    {
        fechaFic = fi.LastWriteTime;
        if (ultimoExif != null && string.IsNullOrWhiteSpace(ultimoFicExif) == false)
        {
            if (Path.GetFileNameWithoutExtension(fi.Name) == ultimoFicExif)
            {
                ficEXIF = ultimoExif;
                fechaFic = Convert.ToDateTime(ficEXIF.DateTaken);
            }
        }
        else
            fechaFic = fi.LastWriteTime;
    }
    else
    {
        // Asignamos el último exitoso
        ultimoExif = ficEXIF;
        ultimoFicExif = Path.GetFileNameWithoutExtension(fi.Name);
        fechaFic = Convert.ToDateTime(ficEXIF.DateTaken);
    }

    return fechaFic;

        

' Para tener en cuenta cuando no se lee el EXIF correctamente
'
' Si es jpg en la función lee los datos EXIF pero al devolverlo está vacío,
' así que usaremos el último exif leído a ver si es el mismo nombre

Private ultimoExif As BitmapMetadata = Nothing
Private ultimoFicExif As String = ""

Private Function FechaExif(fi As FileInfo) As Date
    Dim fechaFic As Date
    Dim ficEXIF = InfoFoto(fi.FullName)
    If ficEXIF Is Nothing OrElse String.IsNullOrEmpty(ficEXIF.DateTaken) Then
        fechaFic = fi.LastWriteTime
        If ultimoExif IsNot Nothing AndAlso String.IsNullOrWhiteSpace(ultimoFicExif) = False Then
            If Path.GetFileNameWithoutExtension(fi.Name) = ultimoFicExif Then
                ficEXIF = ultimoExif
                fechaFic = Convert.ToDateTime(ficEXIF.DateTaken)
            End If
        Else
            fechaFic = fi.LastWriteTime
        End If
    Else
        ' Asignamos el último exitoso
        ultimoExif = ficEXIF
        ultimoFicExif = Path.GetFileNameWithoutExtension(fi.Name)
        fechaFic = Convert.ToDateTime(ficEXIF.DateTaken)
    End If

    Return fechaFic

        

//
// Clase para las extensiones                                   (26/jun/26 02.45)
//
// Convertida de VB a C# con Code Converter (VB - C#) v10.0.1.0
//

// Nota: los comentarios anteriores, los eliminó el "copilot" al mejorar el código de la clase.

using System;
using System.Globalization;
using System.Text;

namespace ImportadorFotos_Dinamico_WPF
{
    /// <summary>
    /// Métodos de extensión auxiliares con pluralización mejorada para español.
    /// Reglas implementadas (versión simplificada):
    /// - Si termina en vocal -> añadir "s".
    /// - Si termina en consonante distinta de 'z' -> añadir "es".
    /// - Si termina en 'z' -> cambiar 'z' por 'c' y añadir "es".
    /// - Si ya termina en 's' (insensible a mayúsculas) -> se considera ya plural/invariable y no se modifica.
    /// Nota: la normalización de tildes (por ejemplo, balón -> balones) se maneja al detectar la letra base
    /// (sin diacríticos) para elegir la regla, pero no se intenta reasignar tildes automáticamente en todos los casos.
    /// </summary>
    public static class Extensiones
    {
        /// <summary>
        /// Devuelve el plural de la palabra <paramref name="singular"/> según el valor <paramref name="count"/>.
        /// Si <paramref name="count"/> != 1, se aplican reglas simplificadas de pluralización en español.
        /// Retorna null si la entrada es null.
        /// </summary>
        /// <param name="singular">Palabra en singular.</param>
        /// <param name="count">Cantidad que determina si debe usarse plural.</param>
        /// <returns>La palabra pluralizada o la original.</returns>
        public static string Plural(this string singular, int count)
        {
            //if (singular is null) return null;
            if (string.IsNullOrWhiteSpace(singular)) return singular; // null o solo espacios
            if (singular.Length == 0) return singular;

            var culture = CultureInfo.CurrentCulture;

            // Detectar si la entrada es todo en mayúsculas (para preservar el estilo)
            bool wasAllUpper = string.Equals(singular, singular.ToUpper(culture), StringComparison.Ordinal);

            // Trabajamos con la palabra recortada en los extremos para aplicar las reglas
            string trimmed = singular.Trim();
            if (trimmed.Length == 0) return singular; // solo espacios

            // Si no hay que pluralizar, devolvemos la original tal cual (manteniendo espacios, si se desean preservar)
            if (count == 1) return singular;

            // Si ya termina en 's' (insensible a mayúsc/minúsc) consideramos que no añadir sufijo
            if (trimmed.EndsWith("s", true, culture))
            {
                return wasAllUpper ? singular.ToUpper(culture) : singular;
            }

            // Para decidir la regla analizamos la letra base (sin diacríticos) del último carácter
            char lastBase = GetLastBaseLetter(trimmed, culture);

            string resultBody;

            if (lastBase == 'z')
            {
                // sustituir z/Z por c/C y añadir "es"
                char lastOrig = trimmed[trimmed.Length - 1];
                bool lastIsUpper = char.IsUpper(lastOrig);
                char replacement = lastIsUpper ? 'C' : 'c';
                resultBody = trimmed.Substring(0, trimmed.Length - 1) + replacement + "es";
            }
            else if (IsVowel(lastBase))
            {
                // termina en vocal -> añadir 's'
                resultBody = trimmed + "s";
            }
            else
            {
                // consonante distinta de z -> añadir 'es'
                resultBody = trimmed + "es";
            }

            // Preservar mayúsculas totales si correspondía
            if (wasAllUpper)
            {
                resultBody = resultBody.ToUpper(culture);
            }

            // Devolvemos el resultado limpio (sin preservar espacios externos)
            return resultBody;
        }

        /// <summary>
        /// Sobrecarga para permitir la llamada desde int:  n.Plural("item")
        /// </summary>
        public static string Plural(this int count, string singular)
        {
            return singular.Plural(count);
        }

        // ---------- Helpers ----------

        // Devuelve la última letra base de la cadena (sin diacríticos), en minúscula cultural.
        private static char GetLastBaseLetter(string s, CultureInfo culture)
        {
            if (string.IsNullOrEmpty(s)) return '\0';
            // Tomamos el último carácter visible
            char last = s[s.Length - 1];

            // Convertir el carácter a su forma sin diacríticos mediante normalización
            string lastStr = last.ToString();
            string decomp = lastStr.Normalize(NormalizationForm.FormD);
            var sb = new StringBuilder();
            foreach (char ch in decomp)
            {
                var cat = CharUnicodeInfo.GetUnicodeCategory(ch);
                if (cat != System.Globalization.UnicodeCategory.NonSpacingMark)
                {
                    sb.Append(ch);
                }
            }
            string recomposed = sb.ToString().Normalize(NormalizationForm.FormC);
            if (recomposed.Length == 0) return char.ToLowerInvariant(last);
            return char.ToLower(recomposed[recomposed.Length - 1], culture);
        }

        private static bool IsVowel(char c)
        {
            return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
        }
    }
}

        

 \f0\emdash   versión mejorada de pluralización
' Soporta reglas simples:
'  - palabras que terminan en vocal: añade "s"  (foto -> fotos)
'  - palabras que terminan en "z": cambia "z" por "ces" (luz -> luces)
'  - palabras que terminan en consonante (no z): añade "es" (balón -> balones)
' Conserva comportamiento cuando n = 1 y preserva MAYÚSCULAS completas.
'
Imports System
Imports System.Runtime.CompilerServices
Imports System.Globalization
Imports System.Text

Module Extensiones

    ''' <summary>
    ''' Devuelve el plural del texto indicado, según el valor sea distinto de 1.
    ''' Ejemplo: "foto".Plural(2) -> "fotos"
    ''' </summary>
    ''' <param name="singular">La palabra a pluralizar (puede ser Nothing).</param>
    ''' <param name="n">El valor a tener en cuenta (será plural si es distinto de 1).</param>
    ''' <returns>La cadena pluralizada o la indicada si no es plural; devuelve Nothing si input es Nothing.</returns>
    <Extension>
    Public Function Plural(singular As String, n As Integer) As String
        ' Reusar la implementación centrada en el entero
        Return Plural(n, singular)
    End Function

    ''' <summary>
    ''' Devuelve el plural del texto indicado, según el valor sea distinto de 1.
    ''' Permite llamar: 2.Plural("foto")
    ''' </summary>
    ''' <param name="n">El valor a tener en cuenta (será plural si es distinto de 1).</param>
    ''' <param name="singular">La palabra a pluralizar (puede ser Nothing).</param>
    ''' <returns>La cadena pluralizada o la indicada si no es plural; devuelve Nothing si input es Nothing.</returns>
    <Extension>
    Public Function Plural(n As Integer, singular As String) As String
        ' Esta comparación no me gusta, no quiero que devuelva Nothing.
        'If singular Is Nothing Then
        '    Return Nothing
        'End If

        ' Mi propuesta:                                         (27/jun/26 22.27)
        If String.IsNullOrWhiteSpace(singular) Then
            Return ""
        End If

        ' Mantener espacios exteriores (si el usuario los usa)
        Dim leading = String.Empty
        Dim trailing = String.Empty
        Dim core = singular

        ' Extraer espacios prefijo/sufijo para devolverlos igual
        Dim iStart = 0
        While iStart < core.Length AndAlso Char.IsWhiteSpace(core(iStart))
            iStart += 1
        End While
        Dim iEnd = core.Length - 1
        While iEnd >= 0 AndAlso Char.IsWhiteSpace(core(iEnd))
            iEnd -= 1
        End While

        If iStart > 0 Then
            leading = core.Substring(0, iStart)
        End If
        If iEnd < core.Length - 1 Then
            trailing = core.Substring(iEnd + 1)
        End If

        If iEnd < iStart Then
            ' La cadena es sólo espacios
            Return singular
        End If

        core = core.Substring(iStart, iEnd - iStart + 1)

        ' Si no es plural, devolver la original (manteniendo espacios)
        If n = 1 Then
            Return $"{leading}{core}{trailing}"
        End If

        ' Detectar si la palabra está en MAYÚSCULAS completas
        Dim isAllUpper = core.Equals(core.ToUpperInvariant(), StringComparison.Ordinal)

        ' Regla simple de pluralización
        Dim pluralCore As String
        If core.Length = 0 Then
            pluralCore = core
        Else
            Dim lastChar As Char = core(core.Length - 1)
            ' Vocales incluyendo tildes
            Dim vowels As String = "aeiouáéíóúAEIOUÁÉÍÓÚ"
            If vowels.IndexOf(lastChar) >= 0 Then
                pluralCore = core & "s"
            ElseIf lastChar = "z"c OrElse lastChar = "Z"c Then
                ' luz -> luces  (z -> ces)
                pluralCore = core.Substring(0, core.Length - 1) & "ces"
            Else
                ' consonante -> añadir "es"
                pluralCore = core & "es"
            End If
        End If

        If isAllUpper Then
            pluralCore = pluralCore.ToUpperInvariant()
        End If

        Return $"{leading}{pluralCore}{trailing}"
    End Function

\emdash   versión mejorada de pluralización
' Soporta reglas simples:
'  - palabras que terminan en vocal: añade "s"  (foto -> fotos)
'  - palabras que terminan en "z": cambia "z" por "ces" (luz -> luces)
'  - palabras que terminan en consonante (no z): añade "es" (balón -> balones)
' Conserva comportamiento cuando n = 1 y preserva MAYÚSCULAS completas.
'
Imports System
Imports System.Runtime.CompilerServices
Imports System.Globalization
Imports System.Text

Module Extensiones

    ''' <summary>
    ''' Devuelve el plural del texto indicado, según el valor sea distinto de 1.
    ''' Ejemplo: "foto".Plural(2) -> "fotos"
    ''' </summary>
    ''' <param name="singular">La palabra a pluralizar (puede ser Nothing).</param>
    ''' <param name="n">El valor a tener en cuenta (será plural si es distinto de 1).</param>
    ''' <returns>La cadena pluralizada o la indicada si no es plural; devuelve Nothing si input es Nothing.</returns>
    <Extension>
    Public Function Plural(singular As String, n As Integer) As String
        ' Reusar la implementación centrada en el entero
        Return Plural(n, singular)
    End Function

    ''' <summary>
    ''' Devuelve el plural del texto indicado, según el valor sea distinto de 1.
    ''' Permite llamar: 2.Plural("foto")
    ''' </summary>
    ''' <param name="n">El valor a tener en cuenta (será plural si es distinto de 1).</param>
    ''' <param name="singular">La palabra a pluralizar (puede ser Nothing).</param>
    ''' <returns>La cadena pluralizada o la indicada si no es plural; devuelve Nothing si input es Nothing.</returns>
    <Extension>
    Public Function Plural(n As Integer, singular As String) As String
        ' Esta comparación no me gusta, no quiero que devuelva Nothing.
        'If singular Is Nothing Then
        '    Return Nothing
        'End If

        ' Mi propuesta:                                         (27/jun/26 22.27)
        If String.IsNullOrWhiteSpace(singular) Then
            Return ""
        End If

        ' Mantener espacios exteriores (si el usuario los usa)
        Dim leading = String.Empty
        Dim trailing = String.Empty
        Dim core = singular

        ' Extraer espacios prefijo/sufijo para devolverlos igual
        Dim iStart = 0
        While iStart < core.Length AndAlso Char.IsWhiteSpace(core(iStart))
            iStart += 1
        End While
        Dim iEnd = core.Length - 1
        While iEnd >= 0 AndAlso Char.IsWhiteSpace(core(iEnd))
            iEnd -= 1
        End While

        If iStart > 0 Then
            leading = core.Substring(0, iStart)
        End If
        If iEnd < core.Length - 1 Then
            trailing = core.Substring(iEnd + 1)
        End If

        If iEnd < iStart Then
            ' La cadena es sólo espacios
            Return singular
        End If

        core = core.Substring(iStart, iEnd - iStart + 1)

        ' Si no es plural, devolver la original (manteniendo espacios)
        If n = 1 Then
            Return $"{leading}{core}{trailing}"
        End If

        ' Detectar si la palabra está en MAYÚSCULAS completas
        Dim isAllUpper = core.Equals(core.ToUpperInvariant(), StringComparison.Ordinal)

        ' Regla simple de pluralización
        Dim pluralCore As String
        If core.Length = 0 Then
            pluralCore = core
        Else
            Dim lastChar As Char = core(core.Length - 1)
            ' Vocales incluyendo tildes
            Dim vowels As String = "aeiouáéíóúAEIOUÁÉÍÓÚ"
            If vowels.IndexOf(lastChar) >= 0 Then
                pluralCore = core & "s"
            ElseIf lastChar = "z"c OrElse lastChar = "Z"c Then
                ' luz -> luces  (z -> ces)
                pluralCore = core.Substring(0, core.Length - 1) & "ces"
            Else
                ' consonante -> añadir "es"
                pluralCore = core & "es"
            End If
        End If

        If isAllUpper Then
            pluralCore = pluralCore.ToUpperInvariant()
        End If

        Return $"{leading}{pluralCore}{trailing}"
    End Function