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


 


Tema destacado: Cifrar documentos-carpetas con GnuPG en Linux y Windows


  Mostrar Mensajes
Páginas: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 [15] 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 ... 1037
141  Programación / .NET / Re: C# - No puedo reproducir la siguiente cancion en: 12 Octubre 2017, 20:19
6. Ya lo probe antes de hacer este post.

7. Ok. Quiero ir por ese camino...

De acuerdo, entonces por si te sirve de algo te muestro un algoritmo que desarrollé hace un par de años para construir listas de reproducción en formato M3U y PLS de forma sencilla. El código es un poco feo, lo escribí hace varios años, se puede refactorizar para perfeccionarlo de muchas formas para representarlo de forma más abstracta y llevar a cabo todas las modificaciones en la memoria sin realizar operaciones de lectura/escritura en el archivo, pero bueno, así lo escribí en su día cuando todavía no dominaba muchas cosas en la progamación .NET, y el caso es que funciona, que es lo importante...

NOTA INFORMATIVA:
--- EL SIGUIENTE CÓDIGO HA SIDO EXTRAIDO Y OFRECIDO DE FORMA GRATUITA A PARTIR DE MI FRAMEWORK COMERCIAL
ELEKTROKIT FRAMEWORK , EL CUAL CONTIENE UNA INFINIDAD DE UTILIDADES ENFOCADAS A UNA AMPLIA VARIEDAD DE TEMÁTICAS Y ESCENARIOS EN LA PROGRAMACIÓN .NET, COMO ÉSTE. SI QUIEREN CONOCER MÁS ACERCA DEL PRODUCTO, MIREN MI FIRMA DE USUARIO EN EL FORO. ---
---
ESTE CÓDIGO SE PUEDE USAR DE FORMA LIBRE COMO DESEEN.


Nota: Debido a que el foro tiene un límite muy reducido de caracteres, me he visto obligado a eliminar gran parte de la documentación XML ( descripciones de parámetros, etc).

Código
  1. #Region " Playlist Type "
  2.  
  3. Namespace ElektroKit.Core.Multimedia.Enums
  4.  
  5.    ''' <summary>
  6.    ''' Specifies the type of a multimedia playlist.
  7.    ''' </summary>
  8.    Public Enum PlaylistType As Integer
  9.  
  10.        ''' <summary>
  11.        ''' M3U Playlist.
  12.        ''' <para></para>
  13.        ''' <see href="http://en.wikipedia.org/wiki/M3U"/>
  14.        ''' </summary>
  15.        M3U = 0I
  16.  
  17.        ''' <summary>
  18.        ''' PLS Playlist.
  19.        ''' <para></para>
  20.        ''' <see href="http://en.wikipedia.org/wiki/PLS_%28file_format%29"/>
  21.        ''' </summary>
  22.        PLS = 1I
  23.  
  24.    End Enum
  25.  
  26. End Namespace
  27.  
  28. #End Region

Código
  1. #Region " Playlist TrackInfo "
  2.  
  3. Namespace ElektroKit.Core.Multimedia.Types
  4.  
  5.    ''' <summary>
  6.    ''' Represents a track of a multimedia playlist.
  7.    ''' </summary>
  8.    Public Structure PlaylistTrackInfo
  9.  
  10. #Region " Properties "
  11.  
  12.        ''' <summary>
  13.        ''' Gets the track index.
  14.        ''' <para></para>
  15.        ''' This value is automatically set by some of the <see cref="PlaylistEditor"/> class members,
  16.        ''' and has none effect if you change it manually.
  17.        ''' </summary>
  18.        Public Property Index As Integer
  19.  
  20.        ''' <summary>
  21.        ''' Gets or sets the file path.
  22.        ''' </summary>
  23.        Public Property Path As String
  24.  
  25.        ''' <summary>
  26.        ''' Gets or sets the track title.
  27.        ''' </summary>
  28.        Public Property Title As String
  29.  
  30.        ''' <summary>
  31.        ''' Gets or sets the track length.
  32.        ''' </summary>
  33.        Public Property Length As TimeSpan
  34.  
  35. #End Region
  36.  
  37.    End Structure
  38.  
  39. End Namespace
  40.  
  41. #End Region

Código
  1. #Region " Imports "
  2.  
  3. Imports System.Collections.ObjectModel
  4. Imports System.IO
  5. Imports System.Text
  6.  
  7. Imports ElektroKit.Core.Multimedia.Enums
  8.  
  9. #End Region
  10.  
  11. #Region " Playlist Editor "
  12.  
  13. Namespace ElektroKit.Core.Multimedia.Types
  14.  
  15.    ''' <summary>
  16.    ''' Contains methods to create and or manage the tracks defined in a multimedia playlist file.
  17.    ''' </summary>
  18.    Public NotInheritable Class PlaylistEditor
  19.  
  20. #Region " Properties "
  21.  
  22.        ''' <summary>
  23.        ''' Gets the playlist filepath.
  24.        ''' </summary>
  25.        Public ReadOnly Property FilePath As String
  26.            <DebuggerStepThrough>
  27.            Get
  28.                Return Me.filepathB
  29.            End Get
  30.        End Property
  31.        ''' ----------------------------------------------------------------------------------------------------
  32.        ''' <summary>
  33.        ''' ( Backing field )
  34.        ''' The playlist filepath.
  35.        ''' </summary>
  36.        ''' ----------------------------------------------------------------------------------------------------
  37.        Private ReadOnly filepathB As String
  38.  
  39.        ''' <summary>
  40.        ''' Gets the playlist type.
  41.        ''' </summary>
  42.        Public ReadOnly Property PlaylistType As PlaylistType
  43.            Get
  44.                Return Me.playlistTypeB
  45.            End Get
  46.        End Property
  47.        Private ReadOnly playlistTypeB As PlaylistType
  48.  
  49.        ''' <summary>
  50.        ''' Gets the text encoding of the playlist file.
  51.        ''' </summary>
  52.        Public ReadOnly Property FileEncoding As Encoding
  53.            Get
  54.                Return Me.encodingB
  55.            End Get
  56.        End Property
  57.        Private ReadOnly encodingB As Encoding
  58.  
  59.        ''' <summary>
  60.        ''' Gets a value indicating whether the text will be appended at the bottom of the playlist file.
  61.        ''' </summary>
  62.        Public ReadOnly Property Append As Boolean
  63.            <DebuggerStepThrough>
  64.            Get
  65.                Return Me.appendB
  66.            End Get
  67.        End Property
  68.        Private ReadOnly appendB As Boolean
  69.  
  70.        ''' <summary>
  71.        ''' Gets a collection that represents the tracks defined (if any) in the playlist.
  72.        ''' </summary>
  73.        Public ReadOnly Property Tracks As ReadOnlyCollection(Of PlaylistTrackInfo)
  74.            <DebuggerStepThrough>
  75.            Get
  76.                Return New ReadOnlyCollection(Of PlaylistTrackInfo)(Me.GetTracks)
  77.            End Get
  78.        End Property
  79.  
  80.        ''' <summary>
  81.        ''' Gets the amount of tracks defined in the playlist.
  82.        ''' </summary>
  83.        Public ReadOnly Property Count As Integer
  84.            <DebuggerStepThrough>
  85.            Get
  86.                Return Me.GetTracks.Count
  87.            End Get
  88.        End Property
  89.  
  90. #End Region
  91.  
  92. #Region " Constructors "
  93.  
  94.        <DebuggerNonUserCode>
  95.        Private Sub New()
  96.        End Sub
  97.  
  98.        ''' <summary>
  99.        ''' Initializes a new instance of the <see cref="PlaylistEditor"/> class.
  100.        ''' </summary>
  101.        '''
  102.        ''' <param name="playlistFile">
  103.        ''' The playlist file path.
  104.        ''' </param>
  105.        ''' <param name="playlistType">
  106.        ''' The type of the playlist.
  107.        ''' </param>
  108.        ''' <param name="createNew">
  109.        ''' If set to <see langword="True"/>,
  110.        ''' the <see cref="PlaylistEditor"/> instance will assume that the playlist file already exist,
  111.        ''' and it will append any new track entries to the bottom of the playlist file.
  112.        ''' <para></para>
  113.        ''' If set to <see langword="False"/>,
  114.        ''' the <see cref="PlaylistEditor"/> instance will assume that the playlist file does not exist,
  115.        ''' so then it will create a new playlist file.
  116.        ''' </param>
  117.        ''' <param name="fileEncoding">
  118.        ''' Optionally indicates the file encoding to perform write and read operations to the playlist file.
  119.        ''' <para></para>
  120.        ''' Default value is: <see cref="Encoding.Default"/>
  121.        ''' </param>
  122.        <DebuggerStepThrough>
  123.        Public Sub New(ByVal playlistFile As String,
  124.                       ByVal playlistType As PlaylistType,
  125.                       ByVal createNew As Boolean,
  126.                       Optional ByVal fileEncoding As Encoding = Nothing)
  127.  
  128.            Me.filepathB = playlistFile
  129.            Me.playlistTypeB = playlistType
  130.            Me.encodingB = If(fileEncoding IsNot Nothing, fileEncoding, Encoding.Default)
  131.            Me.appendB = Not createNew
  132.  
  133.            If Not (appendB) Then
  134.                Me.AddHeaders()
  135.            End If
  136.  
  137.        End Sub
  138.  
  139. #End Region
  140.  
  141. #Region " Public Methods "
  142.  
  143.        ''' <summary>
  144.        ''' Adds a new track entry in the playlist.
  145.        ''' </summary>
  146.        <DebuggerStepThrough>
  147.        Public Sub Add(ByVal filepath As String,
  148.                       Optional ByVal throwOnDuplicate As Boolean = False)
  149.  
  150.            If Not (throwOnDuplicate) AndAlso Me.Exist(filepath) Then
  151.                Throw New ArgumentException("The specified file path already exists in the playlist.",
  152.                                            paramName:="filepath")
  153.            End If
  154.  
  155.            Dim sb As New StringBuilder
  156.  
  157.            Select Case Me.playlistTypeB
  158.  
  159.                Case PlaylistType.M3U
  160.                    sb.AppendLine()
  161.                    sb.AppendLine(filepath)
  162.                    File.AppendAllText(Me.filepathB, sb.ToString(), Me.encodingB)
  163.  
  164.                Case PlaylistType.PLS
  165.                    Dim tacksCount As Integer = Me.GetPlsTrackCount()
  166.                    sb.AppendLine(File.ReadAllText(Me.filepathB, Me.encodingB).
  167.                                    Replace("NumberOfEntries=" & CStr(tacksCount),
  168.                                            "NumberOfEntries=" & CStr(tacksCount + 1)))
  169.  
  170.                    sb.AppendLine(String.Format("File{0}={1}", CStr(tacksCount + 1), filepath.Replace("\", "/")))
  171.                    File.WriteAllText(Me.filepathB, sb.ToString(), Me.encodingB)
  172.  
  173.            End Select
  174.  
  175.            sb.Clear()
  176.        End Sub
  177.  
  178.        ''' <summary>
  179.        ''' Adds a new track in the playlist, with extended track information.
  180.        ''' </summary>
  181.        <DebuggerStepThrough>
  182.        Public Sub Add(ByVal filepath As String, ByVal title As String, ByVal length As TimeSpan,
  183.                       Optional ByVal throwOnDuplicate As Boolean = False)
  184.  
  185.            If Not (throwOnDuplicate) AndAlso Me.Exist(filepath) Then
  186.                Throw New ArgumentException("The specified file path already exists in the playlist.",
  187.                                            paramName:="filepath")
  188.            End If
  189.  
  190.            Dim sb As New StringBuilder
  191.  
  192.            Select Case Me.playlistTypeB
  193.  
  194.                Case PlaylistType.M3U
  195.                    sb.AppendLine()
  196.                    sb.AppendLine(String.Format("#EXTINF:{0},{1}", CStr(Math.Truncate(length.TotalSeconds)), title))
  197.                    sb.AppendLine(filepath)
  198.                    File.AppendAllText(Me.filepathB, sb.ToString(), Me.encodingB)
  199.  
  200.                Case PlaylistType.PLS
  201.                    Dim tacksCount As Integer = Me.GetPlsTrackCount()
  202.                    sb.AppendLine(File.ReadAllText(Me.filepathB, Me.encodingB).
  203.                                         Replace("NumberOfEntries=" & CStr(tacksCount),
  204.                                                 "NumberOfEntries=" & CStr(tacksCount + 1I)))
  205.  
  206.                    sb.AppendLine(String.Format("File{0}={1}", CStr(tacksCount + 1I), filepath.Replace("\", "/")))
  207.                    sb.AppendLine(String.Format("Title{0}={1}", CStr(tacksCount + 1I), title))
  208.                    sb.AppendLine(String.Format("Length{0}={1}", CStr(tacksCount + 1I), CStr(Math.Truncate(length.TotalSeconds))))
  209.                    File.WriteAllText(Me.filepathB, sb.ToString(), Me.encodingB)
  210.  
  211.            End Select
  212.  
  213.            sb.Clear()
  214.        End Sub
  215.  
  216.        ''' <summary>
  217.        ''' Adds a new track in the playlist, with extended track information.
  218.        ''' </summary>
  219.        <DebuggerStepThrough>
  220.        Public Sub Add(ByVal trackInfo As PlaylistTrackInfo,
  221.                       Optional ByVal throwOnDuplicate As Boolean = False)
  222.  
  223.            Me.Add(trackInfo.Path, trackInfo.Title, trackInfo.Length, throwOnDuplicate)
  224.  
  225.        End Sub
  226.  
  227.        ''' <summary>
  228.        ''' Removes the specified track from the playlist.
  229.        ''' </summary>
  230.        <DebuggerStepThrough>
  231.        Public Sub RemoveTrack(ByVal filepath As String)
  232.  
  233.            If Not Me.Exist(filepath) Then
  234.                Throw New ArgumentException("The specified file path does not exists in the playlist.",
  235.                                            paramName:="filepath")
  236.            End If
  237.  
  238.            Dim playlistContent As List(Of String) = File.ReadLines(Me.filepathB, Me.encodingB).ToList()
  239.  
  240.            Select Case Me.playlistTypeB
  241.                Case PlaylistType.M3U
  242.                    Dim entryIndex As Integer =
  243.                        playlistContent.FindIndex(
  244.                        Function(item As String)
  245.                            Return item.Equals(filepath, StringComparison.OrdinalIgnoreCase)
  246.                        End Function)
  247.  
  248.                    playlistContent.RemoveAt(entryIndex)
  249.                    If playlistContent(entryIndex - 1).StartsWith("#EXTINF", StringComparison.OrdinalIgnoreCase) Then
  250.                        playlistContent.RemoveAt(entryIndex - 1)
  251.                    End If
  252.                    File.WriteAllLines(Me.filepathB, playlistContent, Me.encodingB)
  253.  
  254.                Case PlaylistType.PLS
  255.                    Dim entryIndex As Integer =
  256.                        playlistContent.FindIndex(
  257.                        Function(item As String)
  258.                            Return item.ToLower Like "file#*" & filepath.Replace("\", "/").ToLower
  259.                        End Function)
  260.  
  261.                    Dim trackIndexDelimStartIndex As Integer =
  262.                        playlistContent(entryIndex).IndexOf("e", StringComparison.OrdinalIgnoreCase) + 1I
  263.  
  264.                    Dim trackIndexDelimEndIndex As Integer =
  265.                        playlistContent(entryIndex).IndexOf("=", StringComparison.OrdinalIgnoreCase)
  266.  
  267.                    Dim trackIndex As Integer =
  268.                        CInt(playlistContent(entryIndex).Substring(trackIndexDelimStartIndex,
  269.                                                              trackIndexDelimEndIndex - trackIndexDelimStartIndex))
  270.  
  271.                    playlistContent.RemoveAt(entryIndex)
  272.  
  273.                    Dim titleEntryIndex As Integer =
  274.                        playlistContent.FindIndex(Function(item As String)
  275.                                                      Return item.ToLower Like String.Format("title{0}=*", CStr(trackIndex))
  276.                                                  End Function)
  277.  
  278.                    If titleEntryIndex <> -1 Then
  279.                        playlistContent.RemoveAt(titleEntryIndex)
  280.                    End If
  281.  
  282.                    Dim lengthEntryIndex As Integer =
  283.                        playlistContent.FindIndex(Function(item As String)
  284.                                                      Return item.ToLower Like String.Format("length{0}=*", CStr(trackIndex))
  285.                                                  End Function)
  286.  
  287.                    If lengthEntryIndex <> -1I Then
  288.                        playlistContent.RemoveAt(lengthEntryIndex)
  289.                    End If
  290.  
  291.                    Dim numberOfEntriesEntryIndex As Integer =
  292.                        playlistContent.FindIndex(Function(item As String)
  293.                                                      Return item.ToLower Like "numberofentries=#*"
  294.                                                  End Function)
  295.  
  296.                    playlistContent(numberOfEntriesEntryIndex) =
  297.                        String.Format("NumberOfEntries={0}", CStr(Me.GetPlsTrackCount() - 1))
  298.  
  299.                    File.WriteAllLines(Me.filepathB, playlistContent, Me.encodingB)
  300.  
  301.                    Me.FixPlsTrackIndices()
  302.  
  303.            End Select
  304.        End Sub
  305.  
  306.        ''' <summary>
  307.        ''' Removes the specified track from the playlist.
  308.        ''' </summary>
  309.        <DebuggerStepThrough>
  310.        Public Sub RemoveTrack(ByVal trackIndex As Integer)
  311.            Dim track As PlaylistTrackInfo = Me.GetTrackInfo(trackIndex)
  312.  
  313.            If track IsNot Nothing Then
  314.                Me.RemoveTrack(track.Path)
  315.            Else
  316.                Throw New IndexOutOfRangeException("Track index is out of range") With {.Source = "trackIndex"}
  317.            End If
  318.        End Sub
  319.  
  320.        ''' <summary>
  321.        ''' Sets the track info of the specified track.
  322.        ''' </summary>
  323.        <DebuggerStepThrough>
  324.        Public Sub SetTrackInfo(ByVal filepath As String, ByVal trackInfo As PlaylistTrackInfo)
  325.  
  326.            If Not Me.Exist(filepath) Then
  327.                Throw New ArgumentException("The specified file path does not exists in the playlist.",
  328.                                            paramName:="filepath")
  329.            End If
  330.  
  331.            Dim track As PlaylistTrackInfo = Me.GetTrackInfo(filepath)
  332.            With track
  333.                .Path = trackInfo.Path
  334.                .Title = trackInfo.Title
  335.                .Length = trackInfo.Length
  336.            End With
  337.  
  338.            Dim playlistContent As List(Of String) = File.ReadLines(Me.filepathB, Me.encodingB).ToList()
  339.  
  340.            Select Case Me.playlistTypeB
  341.                Case PlaylistType.M3U
  342.                    Dim trackIndex As Integer =
  343.                        playlistContent.FindIndex(
  344.                        Function(item As String)
  345.                            Return item.Equals(filepath, StringComparison.OrdinalIgnoreCase)
  346.                        End Function)
  347.  
  348.                    playlistContent(trackIndex) = String.Format("#EXTINF:{0},{1}",
  349.                                                                CStr(Math.Truncate(track.Length.TotalSeconds)),
  350.                                                                track.Title) & Environment.NewLine & track.Path
  351.  
  352.                    If playlistContent(trackIndex - 1I).StartsWith("#EXTINF", StringComparison.OrdinalIgnoreCase) Then
  353.                        playlistContent.RemoveAt(trackIndex - 1I)
  354.                    End If
  355.  
  356.                    File.WriteAllLines(Me.filepathB, playlistContent, Me.encodingB)
  357.  
  358.                Case PlaylistType.PLS
  359.                    track.Path = track.Path.Replace("\", "/")
  360.  
  361.                    Dim trackIndex As Integer =
  362.                        playlistContent.FindIndex(
  363.                        Function(item As String)
  364.                            Return item.ToLower Like "file#*" & filepath.Replace("\", "/").ToLower
  365.                        End Function)
  366.  
  367.                    playlistContent(trackIndex) = String.Format("File{0}={1}", CStr(track.Index), track.Path) & Environment.NewLine &
  368.                                                  String.Format("Title{0}={1}", CStr(track.Index), track.Title) & Environment.NewLine &
  369.                                                  String.Format("Length{0}={1}", CStr(track.Index), CStr(Math.Truncate(track.Length.TotalSeconds)))
  370.  
  371.                    If playlistContent.Count > (trackIndex + 1) Then
  372.                        If playlistContent(trackIndex + 2).StartsWith("Title", StringComparison.OrdinalIgnoreCase) _
  373.                        OrElse playlistContent(trackIndex + 2).StartsWith("Length", StringComparison.OrdinalIgnoreCase) Then
  374.                            playlistContent.RemoveAt(trackIndex + 2)
  375.                        End If
  376.                    End If
  377.  
  378.                    If playlistContent.Count > trackIndex Then
  379.                        If playlistContent(trackIndex + 1).StartsWith("Title", StringComparison.OrdinalIgnoreCase) _
  380.                        OrElse playlistContent(trackIndex + 1).StartsWith("Length", StringComparison.OrdinalIgnoreCase) Then
  381.                            playlistContent.RemoveAt(trackIndex + 1)
  382.                        End If
  383.                    End If
  384.  
  385.                    File.WriteAllLines(Me.filepathB, playlistContent, Me.encodingB)
  386.            End Select
  387.  
  388.        End Sub
  389.  
  390.        ''' <summary>
  391.        ''' Sets the track info of the specified track.
  392.        ''' </summary>
  393.        <DebuggerStepThrough>
  394.        Public Sub SetTrackInfo(ByVal trackIndex As Integer, ByVal trackInfo As PlaylistTrackInfo)
  395.            If Not Me.Exist(trackIndex) Then
  396.                Throw New IndexOutOfRangeException("Track index is out of range.") With {.Source = "trackIndex"}
  397.            End If
  398.  
  399.            Me.SetTrackInfo(Me.GetTrackInfo(trackIndex).Path, trackInfo)
  400.        End Sub
  401.  
  402.        ''' <summary>
  403.        ''' Finds the specified track in the playlist and returns a
  404.        ''' <see cref="PlaylistTrackInfo"/> instance that represents the track.
  405.        ''' </summary>
  406.        <DebuggerStepThrough>
  407.        Public Function GetTrackInfo(ByVal filepath As String) As PlaylistTrackInfo
  408.  
  409.            Dim playlistContent As List(Of String) = File.ReadLines(Me.filepathB, Me.encodingB).ToList()
  410.            Dim tInfo As New PlaylistTrackInfo
  411.  
  412.            Select Case Me.playlistTypeB
  413.  
  414.                Case PlaylistType.M3U
  415.                    Dim trackIndex As Integer = playlistContent.FindIndex(
  416.                        Function(item As String)
  417.                            Return item.Equals(filepath, StringComparison.OrdinalIgnoreCase)
  418.                        End Function) - 1
  419.  
  420.                    If playlistContent(trackIndex).StartsWith("#EXTINF", StringComparison.OrdinalIgnoreCase) Then
  421.                        Dim titleDelimIndex As Integer = playlistContent(trackIndex).IndexOf(","c) + 1
  422.                        Dim lengthDelimIndex As Integer = playlistContent(trackIndex).IndexOf(":"c) + 1
  423.  
  424.                        With tInfo
  425.                            .Index = trackIndex
  426.                            .Path = filepath
  427.                            .Title = playlistContent(trackIndex).Substring(titleDelimIndex)
  428.                            .Length = TimeSpan.FromSeconds(CDbl(playlistContent(trackIndex).Substring(lengthDelimIndex, (titleDelimIndex - lengthDelimIndex))))
  429.                        End With
  430.                    End If
  431.  
  432.                Case PlaylistType.PLS
  433.                    filepath = filepath.Replace("\", "/")
  434.  
  435.                    Dim entry As String = (From Item As String In playlistContent
  436.                                           Where Item.ToLower Like String.Format("file#*={0}", filepath.ToLower())).SingleOrDefault
  437.  
  438.                    If Not String.IsNullOrEmpty(entry) Then
  439.  
  440.                        Dim indexDelimStartIndex As Integer =
  441.                            entry.IndexOf("e", StringComparison.OrdinalIgnoreCase) + 1I
  442.  
  443.                        Dim indexDelimEndIndex As Integer =
  444.                            entry.IndexOf("=", StringComparison.OrdinalIgnoreCase)
  445.  
  446.                        Dim trackIndex As Integer = CInt(entry.Substring(indexDelimStartIndex,
  447.                                                                    indexDelimEndIndex - indexDelimStartIndex))
  448.  
  449.                        Dim titleEntry As String = (From Item As String In playlistContent
  450.                                                    Where Item.StartsWith(String.Format("Title{0}=", CStr(trackIndex)), StringComparison.OrdinalIgnoreCase)).
  451.                                                    FirstOrDefault
  452.  
  453.                        Dim lengthEntry As String = (From Item As String In playlistContent
  454.                                                     Where Item.StartsWith(String.Format("Length{0}=", CStr(trackIndex)), StringComparison.OrdinalIgnoreCase)).
  455.                                                     FirstOrDefault
  456.  
  457.                        With tInfo
  458.                            .Index = trackIndex
  459.                            .Path = filepath
  460.                            .Title = If(Not String.IsNullOrEmpty(titleEntry),
  461.                                        titleEntry.Substring(titleEntry.IndexOf("=") + 1),
  462.                                        Nothing)
  463.                            .Length = If(Not String.IsNullOrEmpty(titleEntry),
  464.                                         TimeSpan.FromSeconds(CDbl(lengthEntry.Split("="c).LastOrDefault)),
  465.                                         Nothing)
  466.                        End With
  467.  
  468.                    End If
  469.  
  470.            End Select
  471.  
  472.            Return tInfo
  473.  
  474.        End Function
  475.  
  476.        ''' <summary>
  477.        ''' Finds the specified track in the playlist and returns a
  478.        ''' <see cref="PlaylistTrackInfo"/> instance that represents the track.
  479.        ''' </summary>
  480.        <DebuggerStepThrough>
  481.        Public Function GetTrackInfo(ByVal trackIndex As Integer) As PlaylistTrackInfo
  482.  
  483.            Dim playlistContent As List(Of String) = File.ReadLines(Me.filepathB, Me.encodingB).ToList()
  484.  
  485.            Select Case Me.playlistTypeB
  486.  
  487.                Case PlaylistType.M3U
  488.                    Dim trackCount As Integer = 0
  489.  
  490.                    For index As Integer = 0 To (playlistContent.Count - 1)
  491.                        If Not String.IsNullOrEmpty(playlistContent(index)) _
  492.                           AndAlso Not playlistContent(index).StartsWith("#EXT", StringComparison.OrdinalIgnoreCase) Then
  493.  
  494.                            trackCount += 1
  495.                            If (trackCount = trackIndex) Then
  496.                                Dim tInfo As PlaylistTrackInfo = Me.GetTrackInfo(playlistContent(index))
  497.                                With tInfo
  498.                                    .Index = trackIndex
  499.                                    .Path = playlistContent(index)
  500.                                End With
  501.                                Return tInfo
  502.                            End If
  503.  
  504.                        End If
  505.                    Next index
  506.  
  507.                Case PlaylistType.PLS
  508.                    For index As Integer = 0 To (playlistContent.Count - 1)
  509.                        If playlistContent(index).StartsWith(String.Format("File{0}=", CStr(trackIndex)),
  510.                                                             StringComparison.OrdinalIgnoreCase) Then
  511.                            Return Me.GetTrackInfo(playlistContent(index).Substring(playlistContent(index).IndexOf("="c) + 1I))
  512.                        End If
  513.                    Next index
  514.  
  515.            End Select
  516.  
  517.            Return Nothing
  518.        End Function
  519.  
  520.        ''' <summary>
  521.        ''' Determines whether the specified track exists in the playlist.
  522.        ''' </summary>
  523.        <DebuggerStepThrough>
  524.        Public Function Exist(ByVal filepath As String) As Boolean
  525.            Dim returnValue As Boolean = False
  526.  
  527.            Select Case Me.playlistTypeB
  528.                Case PlaylistType.M3U
  529.                    returnValue = (From Item As String In File.ReadLines(Me.filepathB, Me.encodingB)
  530.                                   Where Item.StartsWith(filepath, StringComparison.OrdinalIgnoreCase)).
  531.                                   Any()
  532.  
  533.                Case PlaylistType.PLS
  534.                    returnValue = (From Item As String In File.ReadLines(Me.filepathB, Me.encodingB)
  535.                                   Where Item.ToLower() Like "file#*" & filepath.Replace("\", "/").ToLower()).
  536.                                   Any()
  537.            End Select
  538.  
  539.            Return returnValue
  540.        End Function
  541.  
  542.        ''' <summary>
  543.        ''' Determines whether the specified track exists in the playlist.
  544.        ''' </summary>
  545.        <DebuggerStepThrough>
  546.        Public Function Exist(ByVal trackIndex As Integer) As Boolean
  547.            If (trackIndex <= 0) Then
  548.                Throw New IndexOutOfRangeException("TrackIndex should be greater than 0.") With {.Source = "trackIndex"}
  549.            End If
  550.  
  551.            Return (Me.Count >= trackIndex)
  552.        End Function
  553.  
  554. #End Region
  555.  
  556. #Region " Private Methods "
  557.  
  558.        ''' <summary>
  559.        ''' Collects all the tracks defined in a playlist file and returns a <see cref="List(Of PlaylistTrackInfo)"/>.
  560.        ''' </summary>
  561.        <DebuggerStepThrough>
  562.        Private Function GetTracks() As List(Of PlaylistTrackInfo)
  563.  
  564.            Dim playlistContent As List(Of String) = File.ReadLines(Me.filepathB, Me.encodingB).ToList()
  565.            Dim tInfo As New List(Of PlaylistTrackInfo)
  566.            Dim trackCount As Integer = 0
  567.  
  568.            Select Case Me.playlistTypeB
  569.  
  570.                Case PlaylistType.M3U
  571.                    For index As Integer = 0 To (playlistContent.Count - 1)
  572.                        If Not String.IsNullOrEmpty(playlistContent(index)) _
  573.                           AndAlso Not playlistContent(index).StartsWith("#EXT", StringComparison.OrdinalIgnoreCase) Then
  574.                            trackCount += 1
  575.                            tInfo.Add(Me.GetTrackInfo(trackCount))
  576.                        End If
  577.                    Next
  578.  
  579.                Case PlaylistType.PLS
  580.                    For index As Integer = 0 To (playlistContent.Count - 1)
  581.                        If playlistContent(index).StartsWith("File", StringComparison.OrdinalIgnoreCase) Then
  582.                            trackCount += 1
  583.                            tInfo.Add(Me.GetTrackInfo(trackCount))
  584.                        End If
  585.                    Next index
  586.  
  587.            End Select
  588.  
  589.            Return tInfo
  590.        End Function
  591.  
  592.        ''' <summary>
  593.        ''' Adds the playlist headers at the top of the playlist file.
  594.        ''' <para></para>
  595.        ''' This method should always be called before adding the very first entry in a new (empty) playlist.
  596.        ''' </summary>
  597.        <DebuggerStepThrough>
  598.        Private Sub AddHeaders()
  599.            Dim sb As New StringBuilder
  600.  
  601.            Select Case Me.playlistTypeB
  602.                Case PlaylistType.M3U
  603.                    sb.AppendLine("#EXTM3U")
  604.  
  605.                Case PlaylistType.PLS
  606.                    With sb
  607.                        .AppendLine("[playlist]")
  608.                        .AppendLine("NumberOfEntries=0")
  609.                        .AppendLine("Version=2")
  610.                    End With
  611.            End Select
  612.  
  613.            File.WriteAllText(Me.filepathB, sb.ToString(), Me.encodingB)
  614.            sb.Clear()
  615.        End Sub
  616.  
  617.        ''' <summary>
  618.        ''' Gets the amount of total tracks defined in a PLS playlist file.
  619.        ''' </summary>
  620.        <DebuggerStepThrough>
  621.        Private Function GetPlsTrackCount() As Integer
  622.            Dim playlistContent As String = File.ReadAllText(Me.filepathB, Me.encodingB)
  623.  
  624.            Dim startIndex As Integer =
  625.                playlistContent.IndexOf("=") + 1I
  626.  
  627.            Dim endIndex As Integer =
  628.                playlistContent.IndexOf(ControlChars.NewLine, startIndex) - startIndex
  629.  
  630.            Return CInt(playlistContent.Substring(startIndex, playlistContent.IndexOf(String.Empty, endIndex)))
  631.        End Function
  632.  
  633.        ''' <summary>
  634.        ''' Fixes the track indices of a PLS playlist file.
  635.        ''' <para></para>
  636.        ''' This method shoould always be called after removing a track from the playlist.
  637.        ''' </summary>
  638.        <DebuggerStepThrough>
  639.        Private Sub FixPlsTrackIndices()
  640.  
  641.            Dim playlistContent As List(Of String) = File.ReadLines(Me.filepathB, Me.encodingB).ToList()
  642.            Dim trackCount As Integer = 0I
  643.  
  644.            For index As Integer = 0 To (playlistContent.Count - 1I)
  645.  
  646.                If playlistContent(index).StartsWith("File", StringComparison.OrdinalIgnoreCase) Then
  647.                    trackCount += 1I
  648.                    playlistContent(index) = String.Format("File{0}={1}",
  649.                                                           CStr(trackCount),
  650.                                                           playlistContent(index).Substring(playlistContent(index).IndexOf("="c) + 1I))
  651.  
  652.                ElseIf playlistContent(index).StartsWith("Title", StringComparison.OrdinalIgnoreCase) Then
  653.                    playlistContent(index) = String.Format("Title{0}={1}",
  654.                                                           CStr(trackCount),
  655.                                                           playlistContent(index).Substring(playlistContent(index).IndexOf("="c) + 1I))
  656.  
  657.                ElseIf playlistContent(index).StartsWith("Length", StringComparison.OrdinalIgnoreCase) Then
  658.                    playlistContent(index) = String.Format("Length{0}={1}",
  659.                                                           CStr(trackCount),
  660.                                                           playlistContent(index).Substring(playlistContent(index).IndexOf("="c) + 1I))
  661.  
  662.                End If
  663.            Next index
  664.  
  665.            Dim numberOfEntriesEntryIndex As Integer =
  666.                playlistContent.FindIndex(Function(item As String)
  667.                                              Return item.ToLower Like "numberofentries=#*"
  668.                                          End Function)
  669.  
  670.            playlistContent(numberOfEntriesEntryIndex) =
  671.                String.Format("NumberOfEntries={0}", CStr(trackCount))
  672.  
  673.            File.WriteAllLines(Me.filepathB, playlistContent, Me.encodingB)
  674.        End Sub
  675.  
  676. #End Region
  677.  
  678.    End Class
  679.  
  680. End Namespace
  681.  
  682. #End Region



El código de arriba puedes tomarlo como ejemplo y nada más para saber como sería una posible manera de poder hacerlo, o bien puedes copiar y pegarlo en una nueva clase de VB.NET para compilarlo en una dll y usarlo en C#, o también puedes convertir directamente el código a C# por ejemplo usando mi conversor de código gratuito ( todos los créditos y copyright para Telerik xD ):




Modo de empleo:
Código
  1. PlaylistEditor editor = new PlaylistEditor(@"C:\playlist.m3u", PlaylistType.M3U, createNew: true);
  2. editor.Add("C:\\File 1.mp3");
  3. editor.Add("C:\\File 2.mp3");

O bien:
Código
  1. PlaylistEditor editor = new PlaylistEditor(@"C:\playlist.m3u", PlaylistType.M3U, createNew: true);
  2.  
  3. PlaylistTrackInfo trackInfo = new PlaylistTrackInfo();
  4. trackInfo.Path = "C:\\File.mp3";
  5. trackInfo.Title = {Track Title or Display Name};
  6. trackInfo.Length = {Track Duration};
  7.  
  8. editor.Add(trackInfo);

Saludos
142  Programación / .NET / Re: C# - No puedo reproducir la siguiente cancion en: 12 Octubre 2017, 20:13
1. No es lo mismo OpenFileDialog ofd = new OpenFileDialog(); que System.Windows.Forms.OpenFileDialog ofd = new System.Windows.Forms.OpenFileDialog();?

Si, por supuesto, simplemente borré el nombre del namespace al citar tu código, y lo cité solamente para hacer referencia a la instrucción de tú código a la que me estaba refiriendo, pero a lo que me refería es a que debes utilizar la sentencia using para asegurarte de que el GC (Garbage Collector) libere cualquier recurso administrado y no administrado que haya sido utilizado por "X" instancia IDisposable... y así tener (o al menos intentarlo) una aplicación libre de las indeseadas fugas de consumo RAM.

Es decir:
Código
  1. using ( OpenFileDialog ofd = new OpenFileDialog() ) {
  2. // ...
  3. }

...o en su defecto puedes usar el método IDisposable.Dispose() ( OpenFileDialog.Dispose() ).



2. Es necesario que lo que haga de esta manera ya que necesito por un lado mostrar los nombres de las canciones en el listBox y por el otro lado guardar las rutas para reproducir esas canciones. Y aunque los nombres sean partes de las rutas... separarlos, segun yo, lleva mas tiempo que el codigo espagueti.

No, no es necesario ni tampoco lleva más tiempo en términos de esfuerzo. En mi última respuesta te mostré un código en el que utilizo una colección genérica de tipo SortedList para almacenar ambos datos... y cuyos elementos se mantienen ordenados por orden alfabético según el nombre de cada archivo agregado en o eliminado de la colección...

Como ves, es una mejora que simplifica tres funcionalidades del código original, en una sola.



3. Bueno eso tendre que cambiarlo. Gracias por la informacion. :)

Si sigues la solución que te indiqué (vease el código que compartí en mi última respuesta) entonces no necesitas usar el método Add / AddRange ya que en su lugar se utiliza la colección SortedList como datasource. Pero de todos modos la utilización del método AddRange es una mejora significativa que siempre deberías tener en cuenta cuando necesites agregar elementos manualmente a un control de tipo Lista (ListBox, ListView, DataGridView, etc).



4. Yo no veo ninguna instruccion de mas. Solamente le asigne una vez una valor a ListBox.Sorted.

Citar
Código
  1.            foreach (var file in ofd.SafeFileNames)
  2.            {
  3.                listBox1.Items.Add(file);
  4.                list1.Add(file);
  5.                listBox1.Sorted = true;
  6.            }

Fíjate bien, le estás reasignando el valor en cada iteración del búcle foreach, es decir, 'listBox1.Sorted = true' por cada elemento en 'ofd.SafeFileNames'.
143  Programación / .NET / Re: incrustar música .mp3 en un formulario . en: 12 Octubre 2017, 19:57
cuando ejecuto el form, empieza a reproducir la música y no aparece el form hasta dentro de unos 4 seg y despues que aparece el form pa musica se detiene?.

como le hago?

El método SoundPlayer.PlaySync, como su propio nombre indica es sincrónico, es lo que se conoce como una llamada bloqueante. En otras palabras: es así por defecto, la cola de mensajes del thread de la UI se bloqueará hasta que se termine de reproducir la canción. Lo mismo te ocurriría si iterases un búcle infinito antes de cargar la UI... o despues, cuando sea.

¿Solución?, prueba a usar el método SoundPlayer.Play a secas (en teoría es asincrónico), o sino, puedes ejecutar la llamada al método SoundPlayer.PlaySync desde un nuevo thread.


Saludos
144  Programación / .NET / Re: incrustar música .mp3 en un formulario . en: 12 Octubre 2017, 17:47
se podría meter una música en la pestaña resources

Si, puedes añadir y embedir cualquier tipo de archivo a la tabla de recursos de tu executable.


yo pienso que se debería incrustar como los txt en la parte de resources pero no se como poner el mp3

Pues exactamente de la misma manera, ¿cual es el problema que le encuentras?, simplemente seleccionas el archivo que quieres añadir como recurso, o directamente desde el explorador de Windows usas el ratón para arrastrar el archivo a la IDE (teniendo la pestaña de recursos abierta) y así se añade...

En otro post te mostré un enlace a MSDN donde te explican como añadir recursos...

y después agregar el control de windows media player y el directorio poner esa musica?

Si, siempre y cuando primero extraigas los datos raw del recurso para generar un archivo local en el disco, y que así el host de WMP pueda reproducirlo, puesto que WMP solo acepta un nombre de archivo o una url. En otras palabras: no puedes usar WMP para reproducir un recurso de audio si no lo extraes al disco, lo cual no se si supone una complicación o no para las intenciones que tengas, de todas formas en otro post te mostré un código para extraer recursos y guardarlos en el disco...

Si lo que quieres es cargar diréctamente el stream del recurso de audio para reproducirlo, entonces puedes usar la clase System.Media.SoundPlayer (del set de librerías para la tecnología WPF) de la siguiente manera:

Código
  1. Imports System.Media
Código
  1. Using waveStream As UnmanagedMemoryStream = My.Resources.ResourceManager.GetStream("Nombre del recurso WAV"),
  2.      player As New SoundPlayer(waveStream)
  3.  
  4.    player.PlaySync()
  5. End Using

Nota: pero no reproduce archivos MP3, el archivo de recurso tiene que ser en formato WAV.
Nota 2: No te preocupes si programas bajo la tecnología Windows Forms, puedes usar los miembros de WPF igualmente.

Aquí tienes una guía:

Saludos
145  Foros Generales / Foro Libre / Re: El Efecto Mandela es real: "Luke, yo soy tu padre" en: 12 Octubre 2017, 16:49
¿Por qué cambia la estatua y las imágenes de la estatua, pero no la mente? Por qué casualmente eso.

Buena pregunta... para la cual no hay respuesta. El ser humano no sabe de donde viene, no puede explicar la manifestación y la presencia de El Universo, no sabe exactamente que es, ni que hace ahí, ni que hacemos nosotros dentro de él. La Ciencia a nivel molecular no conoce el cerebro humano, es un rompecabezas indescifrable de energía, ni siquiera nos conocemos nosotros mismos lo suficiente a nivel físico de forma superficial, y ya ni te cuento a nivel filosófico-espiritual... ahí todo humano se encuentra perdido intentando reconocerse asimismo, así que siendo un ser humano con una capacidad de comprensión limitada me parece en vano pensar que toda esa gente, esas millones de personas y yo incluido estemos confundidos, delirando o incluso fingiendo, o pensar que por el contrario no lo estemos haciendo y resulte ser verdad que tengamos razón y la realidad haya cambiado (al menos para nosotros). Es en vano discutir, no se puede demostrar...o al menos por ahora.

El hecho de que haya escenas y diálogos en películas que han cambiado o dejado de existir, o esculturas que han cambiado, son hechos que dan lugar a dejar la puerta abierta para que pueda haber muchas más cosas que hayan cambiado y todavía no hemos descubierto, y que puedan ser cambios que afecten a la humanidad a un nivel global, como por ejemplo el resultado de una guerra mundial, o vete a saber el qué.

Para mi, personálmente hablando, la capacidad de haberme dado cuenta de algunos de esos cambios, es decir, de saber que han cambiado por que al verlo ahora son distinto de como sé que eran antes, eso es algo que me lo tomo como una especie de prueba la cual demuestra que la mente, el tiempo y lo que es real o deja de serlo no tienen una relación tan estrecha entre si, no están...unidos, por que la mente, el yo, y la realidad trabajan de forma extraña, desordenada, desincronizada tal vez, y parece que tiene más prioridad la mente (o el alma) que la propia realidad. No sé como expresarlo, solo puedo decir que algo así te hace reflexionar, te hace pensar en todo y darle vueltas a las "leyes" por las que se rige la mente para no verse afectada por los cambios al ritmo que cambia la realidad, y la mente se da cuenta de que ha cambiado. Es extraño vivir las consecuencias del Efecto Mandela por que uno debe asimilar que la realidad puede cambiar, pero tus recuerdos, aquello que has vivido, aprendido y memorizado a la perfección, eso no cambia, y en fin... intentar asimilar todo eso es bastante desconcertante.

Pero así como al parecer en ciertas circunstancias desconocidas la mente tiene el poder de ser "inmune" al Efecto Mandela, también es muy capaz de olvidar, de borrar recuerdos, y eso hace más complicada la reflexión sobre el Efecto Mandela y el poder y la fragilidad de la mente, como cualquier intento de comprender la realidad, nuestro cuerpo físico y mental y todo lo que le concierne...

No sé si esto se sale mucho del tema, pero os dejo por aquí un video para reflexionar sobre la inestabilidad que a veces tiene la mente para olvidar (cuando no debería olvidar) sucesos que te cambiaron la vida a mejor...



Saludos
146  Foros Generales / Foro Libre / Re: El Efecto Mandela es real: "Luke, yo soy tu padre" en: 12 Octubre 2017, 14:51
Es imposible discutir cualquier tema cuando te adhieres a explicaciones extravagantes sin rigor científico ni lógico. ¿Por qué no dar explicaciones basadas en las certezas que tienes? Poco a poco, "bottom-up", basado en conceptos claros. Si haces un "top-down", al menos, que esté enlazado con conceptos claros y probables.

Eso es facil decirlo, ahora bien, ¿qué me propones para intentar demostrar algo que solo sigue existiendo en la mente / memoria de las personas?. Algunos casos conocidos y genuinos del efecto mandela apuntan a que, aparte de los recuerdos también pueden existir evidencias de "residuos" que no han cambiado (ej.: en el caso de la escultura del pensador podemos ver fotos de turistas que imitan la pose del pensador... y se ponen la mano en la frente, como yo lo recuerdo y como sé que fue), pero no son pruebas irrefutables para demostrar que la realidad ha cambiado para algunas personas.

Para mi tampoco es lógico, pero así es la realidad (nunca mejor dicho) e intento limitarme a asimilar tal realidad, por que si le intentase buscar alguna explicación "lógica" a estos cambios... me acabaría volviendo loco de verdad. Pero eso no significa que no exista un rigor científico que defiende la teoría de universos paralelos, como bien ya sabes, pero sinceramente intentar atribuirle estos fenómenos inexplicables en la realidad a ¿un choque entre universos paralelos? o ¿las consecuencias del mal uso de una tecnología de viajes en el tiempo al pasado? no serían el tipo de explicación que me acabaría tranquilizando, más bien todo lo contrario, me daría bastante miedo que estos cambios en la realidad tuviesen una explicación científica por así decirlo...

Yo no sé que creer, me refiero a lo que puede haber provocado estos cambios, pero si tengo que elegir entonces prefiero pensar que se debe a temas de física cuántica o cosas así, es decir, que los cambios producidos en el pasado y que afectan al presente son efectos "naturales" que no se pueden controlar por el ser humano, por que si esto se pudiera controlar por el arrogante ser humano en el futuro...adiós al mundo que conocemos.

Tampoco descarto que los experimentos del CERN puedan haber producido y/o magnificado de forma involuntaria algunos o todos estos fenómenos del efecto mandela que estamos sufriendo. Será un complejo subterrano con altos controles de seguridad para evitar accidentes de cualquier tipo y todo lo que quieras, pero están jugando a ser Dios, y eso podría tener consecuencias desconocidas e indetectables para todo el que se atreva a llegar más lejos...

Saludos
147  Programación / .NET / Re: C# - No puedo reproducir la siguiente cancion en: 12 Octubre 2017, 13:50
1.
No estás liberando la instancia de una clase que implementa la interfaz IDisposable...
Citar
Código
  1. OpenFileDialog ofd = new OpenFileDialog();

2.
Estás usando una colección genérica de tipo List para almacenar las rutas absolutas de unos archivos, y luego otra lista adicional para almacenar los nombres de archivo. Tener dos colecciones distintas para practicamente la misma finalidad (puesto que los nombres de archivo son parte de la ruta absoluta del archivo) es algo completamente innecesario con lo que solo conseguirás escribir un código espagueti (confuso y destructurado) más si les asignas nombres como "list1", "list2" y "list3"...

Hay que mejorar las nomenclaturas de los miembros.

3.
Debido a que estás representando una colección de elementos (nombres de archivos), en lugar de utilizar el método ListBox.Add() deberías utilizar el método ListBox.AddRange() para mejorar el rendimiento de la aplicación y la respuesta de la UI. Con cada llamada individual que haces a ListBox.Add() el control envia mensajes de ventana para redibujarse, y eso para añadir 20 canciones no pasa nada, pero si fuesen muchas más pues...acabarías bloqueando la UI por momentos.

4.
Estás reasignando el mismo valor a la propiedad ListBox.Sorted en el controlador button1_Click, esto son instrucciones de más, algo innecesario. Con asignarle el valor a la propiedad una única vez al cargar el control es suficiente.

5..
No estás comprobando el resultado del diálogo cuando seleccionas archivos... ¿qué ocurre si el usuario cancela la selección?. debes comprobarlo...

6..
cuando termina la cancion no se reproduce la siguiente.

Prueba a invocar la funcionalidad de reproducir...
Código
  1. this.axWindowsMediaPlayer1.Ctlcontrols.play();


7..
Citar
Código
  1. int index = 0;
  2. ...
  3. void ... {
  4.    index = index + 1;
  5.    if (index - 1 < listBox1.Items.Count) {
  6.        axWindowsMediaPlayer1.URL = list2[list1.IndexOf(listBox1.Items[index].ToString())];
  7.    }
  8. }

En lugar de la necesidad de declarar un contador y comprobar el estado del reproductor e ir reasignando a cada rato el valor de la propiedad URL para reproducir la siguiente canción, en lugar de todo eso algo más simple sería que añadieses los elementos del ListBox (las rutas completas de los archivos a reproducir) en una lista de reproducción ( playlist.m3u ) para que el WMP las vaya reproduciendo una tras otra y no tengas que hacer más...

Tienes dos opciones para ello, puedes escribir un archivo de lista de reproducción m3u (no es complicado, es un formato muy sencillo):

O bien puedes puedes crear una lista de manera guiada para usarlo en la instancia actual del WMP mediante la interfáz IWMPPlaylist

8..  
Citar
Código:
if (e.newState == 8)

¿Has verificado que el valor de la propiedad NewState sea realmente 8 al terminar de reproducir la canción?. La documentación oficial en la MSDN no recomienda que un algoritmo se base en la "predicción" de los estados del reproductor debido a que al parecer son un poco...impredecibles.

Cita de: MSDN
Remarks

Windows Media Player states are not guaranteed to occur in any particular order. Furthermore, not every state necessarily occurs during a sequence of events. You should not write code that relies upon state order.


Nota: En la página de la MSDN tienes un ejemplo extendido para depurar/testear el estado actual del reproductor.



En general todo el código que tienes ahora mismo lo puedes mejorar y simplificar / refactorizar a algo parecido a esto:

Código
  1. using System;
  2. using System.Collections.Generic;
  3. using System.IO;
  4. using System.Linq;
  5. using System.Windows.Forms;
  6.  
  7. public sealed class Form1 : Form {
  8.  
  9.    const int WMP_MediaEnded = 0x8;
  10.    private readonly SortedList<string, string> files; // { Key=file_name, Value=full_path }
  11.  
  12.    private void Form_Load(object sender, EventArgs e) {
  13.        this.files = new SortedList<string, string>(StringComparer.Ordinal);
  14.        this.listBox1.ValueMember = "key"; // file names
  15.    }
  16.  
  17.    private void Button1_Click(object sender, EventArgs e) {
  18.        using (OpenFileDialog ofd = new OpenFileDialog { Multiselect = true }) {
  19.            ofd.ShowDialog();
  20.  
  21.            DialogResult result = ofd.ShowDialog();
  22.            if (result == DialogResult.OK) {
  23.                foreach (string filepath in ofd.FileNames) {
  24.                    this.files.Add(Path.GetFileName(filepath), filepath);
  25.                }
  26.                this.listBox1.BeginUpdate();
  27.                this.listBox1.DataSource = this.files.ToList();
  28.                this.listBox1.EndUpdate();
  29.            } // if
  30.        } // using
  31.    }
  32.  
  33.    private void ListBox1_DoubleClick(object sender, EventArgs e) {
  34.        this.PlaySongFile(((ListBox)sender).SelectedIndex);
  35.    }
  36.  
  37.    private void PlaySongFile(int fileIndex) {
  38.        ListBox lb = this.listBox1;
  39.        lb.SetSelected(fileIndex, true); // Select the item/song name that is being played.
  40.  
  41.        KeyValuePair<string, string> file = (KeyValuePair<string, string>)lb.SelectedItem;
  42.        this.axWindowsMediaPlayer1.URL = file.Value; // full file path
  43.        this.axWindowsMediaPlayer1.Ctlcontrols.play();
  44.    }
  45.  
  46.    private void AxWindowsMediaPlayer1_PlayStateChange(object sender, AxWMPLib._WMPOCXEvents_PlayStateChangeEvent e) {
  47.  
  48.        if (e.newState == WMP_MediaEnded) {
  49.            int selectedIndex = this.listBox1.SelectedIndex;
  50.            if (this.files.Count < (selectedIndex - 1)) {
  51.                this.PlaySongFile(selectedIndex + 1); // Play next item/song file.
  52.            }
  53.        }
  54.    }
  55.  
  56. }

Nota: Es solo un código de ejemplo para que lo adaptes a tus necesidades, falta que asocies los controladores de evento en el código, no he comprobado que funcione lo de reproducir canciones en el WMP, y tampoco he implementado la funcionalidad de la lista de reproducción ya que lo he propuesto como una mejora opcional y bueno... no voy a hacer yo todo el trabajo, jeje.

Saludos.
148  Foros Generales / Foro Libre / Re: El Efecto Mandela es real: "Luke, yo soy tu padre" en: 12 Octubre 2017, 12:29
¿Sabes?... es mucho mas sencillo y obvio asumir que viste una versión diferente de la original y creiste en ese momento que "era así". Las realidades no cambian, la memoria de las personas es muy fragil y poco fiable

hmmm... ya. Me gustaría ver si seguirías opinando lo mismo si en lugar de cuestionarme a mi, estuviesemos cuestionandote a ti, y lo que se estuviese cuestionando en concreto fuese el color del cielo, donde tu dirías que para ti es (o era) azul, pero para los demás es de otro color, y claro, tu parecerías un "loco" diciendo que el cielo siempre ha sido de otro color al que tu sabes y recuerdas. Ya veriamos como te quedarías si alguien te responde tan pancho diciendo "Las realidades no cambian, la memoria de las personas es muy fragil y poco fiable" cuestionándote algo que sabes a la perfección que no se le puede atribuir a un fallo de la mente ni nada por el estilo... pero claro, a esa persona no se lo pdorías demostrar, tendrías que tragarte sus palabras y dejar que él siga en su incredulidad.

Como ya dije al principio, de nada sirve intentar debatir este tema para intentar demostrar nada, sencillamente es imposible, una vez que la realidad ha cambiado... la única prueba que permanece está en la memoria del que recuerda.

Seguro que conoces el cuadro "La Gioconda". Lo conoce TODO el mundo. Ahora quiero saber cuantos pueden decir sin mirar el cuadro en internet, "de memoria" cuantos arcos tiene el puente que se ve a su derecha.

¿Como... que... puente?.... pues si, hay un puente pequeño en el fondo ¿Era invisible y nadie lo había visto? No, muchos estudiantes de arte te dirán que "siempre ha estado ahí" pero los que solo "miran" el cuadro no se centran en esos detalles

Sé por donde vas, y no me puedes pretender tener el descaro de comparar un diminuto puente que hace de "bulto" en el cuadro (puesto que es un retrato, los detalles del paisaje son algo en lo que las personas por lo general no van a fijar toda su atención, a menos que estudien arte como tú has dicho) con la capacidad que tiene el ser humano por naturaleza para grabar en su cerebro y recordar el aspecto facial de una persona y/o caricatura, como "animales" sociales que somos, está en nuestros genes quedarnos con las caras y los gestos de la gente... es lo primero que hacemos al conocer a alguien.

No voy a hablar sobre ese efecto mandele relacionado con la sonrisa de la mona lisa, por que sinceramente es algo que yo no sabría decir, no lo recuerdo perfectamente, pero quien sabe.

saludos
149  Foros Generales / Foro Libre / Re: El Efecto Mandela es real: "Luke, yo soy tu padre" en: 12 Octubre 2017, 05:02
Tu dices que "todos sabemos que"... pues oye, yo la he visto varias veces expuesta (por ejemplo en el museo de arte contemporaneo de Tokyo) y está con la mano en la barbilla

De hecho lo "dificil" es encontrar una imagen donde esté con la mano como un puño en la frente, lo que me hace pensar que debe de tratarse de alguna otra obra

Que tu la hayas visto con la mano en la barbilla solo significa que esa es tu realidad. Es imposible discutir este tema para llegar a una "prueba convincente" que valga para ti, puesto que en tu realidad la mano siempre ha estado en la barbilla. Seguirás diciendo que la excultura siempre ha sido así, que la has visto, que no existen imágenes de la escultura con la mano en la frente, etc, cosa que es verdad (en esta realidad), pero también es verdad que la escultura tenía la mano puesta en la frente, y eso una persona incapaz de asimilar que la realidad pueda haber cambiado pues... eso, no lo puede asimilar. A mi me cuesta mucho asimilarlo.

Saludos
150  Informática / Multimedia / Re: ¿Software para ver canales de TV en el PC sin tarjeta sintonizadora? en: 11 Octubre 2017, 08:31
solo hace falta encontrar algún enlace de iptv/rtsp correcto de tu país

Ejemplo: canal 26 de argentina rtsp://live-edge01.telecentro.net.ar:80/live/26hd-720

Gracias pero la idea es apoyarme en un programa que controle ese tipo de cosas y proporcione ya los canales para no tener que preocuparme yo de investigar y encontrar direcciones de streaming iptv/rtsp e ir renovándolas con el tiempo por que supongo que irán muriendo o cambiando...

La idea que me propones si no he entendido mal consiste en ir construyendo tu propia lista de canales, uno a uno. No es lo que yo tenía pensado, jeje.

gracias igualmente.

saludos!
Páginas: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 [15] 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 ... 1037
Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines