private IEnumerable <LinkedChild> GetM3uItems(Stream stream)
{
var content = new M3uContent();
var playlist = content.GetFromStream(stream);
return(playlist.PlaylistEntries.Select(i => new LinkedChild
{
Path = i.Path,
Type = LinkedChildType.Manual
}));
}
public void Save(string filePath, IPlaylist playlist)
{
M3uPlaylist m3uPlaylist = MapToEntity(playlist);
M3uContent content = new M3uContent();
string text = content.ToText(m3uPlaylist);
using (StreamWriter sw = new StreamWriter(filePath))
{
sw.Write(text);
}
}
static M3uPlaylist GetPlaylistFromFile(string path)
{
var playlist = new M3uPlaylist();
var content = new M3uContent();
using (MemoryStream ms = new MemoryStream())
using (FileStream stream = File.Open(path, FileMode.Open))
{
playlist = content.GetFromStream(stream);
}
return(playlist);
}
public void GetFromStream_ReadPlaylistNotExtendedAndCompareWithObject_Equal()
{
M3uContent content = new M3uContent();
M3uPlaylist playlist = new M3uPlaylist();
playlist.IsExtended = false;
playlist.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Album = "",
AlbumArtist = "",
Duration = TimeSpan.Zero,
Path = @"D:\Muzyka\Andrea Bocelli\04 Chiara.mp3",
Title = "",
});
playlist.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Album = null,
AlbumArtist = null,
Duration = TimeSpan.Zero,
Path = @"D:\Muzyka\Andrea Bocelli\01 Con Te Partiro.mp3",
Title = null,
});
playlist.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Album = "Unknown",
AlbumArtist = "Andrea Bocelli",
Duration = TimeSpan.Zero,
Path = @"D:\Muzyka\Andrea Bocelli\04 E Chiove.mp3",
Title = "E Chiove",
});
using (var stream = Helpers.ReadStream("PlaylistNotExt.m3u"))
{
var file = content.GetFromStream(stream);
Assert.AreEqual(playlist.IsExtended, file.IsExtended);
Assert.AreEqual(playlist.PlaylistEntries.Count, file.PlaylistEntries.Count);
Assert.AreEqual(playlist.PlaylistEntries[0].Path, file.PlaylistEntries[0].Path);
Assert.AreEqual(playlist.PlaylistEntries[0].Title, file.PlaylistEntries[0].Title);
Assert.AreEqual(playlist.PlaylistEntries[1].Path, file.PlaylistEntries[1].Path);
Assert.AreNotEqual(playlist.PlaylistEntries[1].Title, file.PlaylistEntries[1].Title);
Assert.IsNull(playlist.PlaylistEntries[1].Title);
Assert.AreEqual("", file.PlaylistEntries[1].Title);
Assert.AreEqual(playlist.PlaylistEntries[2].Path, file.PlaylistEntries[2].Path);
Assert.AreNotEqual(playlist.PlaylistEntries[2].Title, file.PlaylistEntries[2].Title);
}
}
public List <PlayListEntry> GetPlayList()
{
var playlist = Path.Combine(_appEnvironment.WebRootPath, "playlist.m3u");
using var file = new FileStream(playlist, FileMode.Open);
var content = new M3uContent();
var playlists = content.GetFromStream(file);
return(playlists.PlaylistEntries.Select((p, i) => new PlayListEntry()
{
name = p.Title + playlists.Comments.Skip(i).FirstOrDefault(),
url = p.Path
}).Where(p => p.url.StartsWith("rtp://")).ToList());
}
public void GetFromStream_ReadPlaylistExtendedAndCompareWithObject_Equal()
{
M3uContent content = new M3uContent();
M3uPlaylist playlist = new M3uPlaylist();
playlist.IsExtended = true;
playlist.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Album = "",
AlbumArtist = "",
Duration = TimeSpan.FromSeconds(254),
Path = @"D:\Muzyka\Andrea Bocelli\04 Chiara.mp3",
Title = "Andrea Bocelli - Chiara",
});
playlist.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Album = null,
AlbumArtist = null,
Duration = TimeSpan.FromSeconds(-1),
Path = @"D:\Muzyka\Andrea Bocelli\01 Con Te Partiro.mp3",
Title = "Andrea Bocelli - Con Te Partiro",
});
playlist.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Album = "AndreaBocelli",
AlbumArtist = "Andrea Bocelli",
Duration = TimeSpan.FromSeconds(-1),
Path = @"D:\Muzyka\Andrea Bocelli\04 E Chiove.mp3",
Title = "Andrea Bocelli - E Chiove",
});
var stream = Helpers.ReadStream("PlaylistExt.m3u");
var file = content.GetFromStream(stream);
stream.Dispose();
Assert.AreEqual(playlist.IsExtended, file.IsExtended);
Assert.AreEqual(playlist.PlaylistEntries.Count, file.PlaylistEntries.Count);
Assert.AreEqual(playlist.PlaylistEntries[0].Path, file.PlaylistEntries[0].Path);
Assert.AreEqual(playlist.PlaylistEntries[0].Title, file.PlaylistEntries[0].Title);
Assert.AreEqual(playlist.PlaylistEntries[0].Album, file.PlaylistEntries[0].Album);
Assert.AreEqual(playlist.PlaylistEntries[0].AlbumArtist, file.PlaylistEntries[0].AlbumArtist);
Assert.AreEqual(playlist.PlaylistEntries[1].Path, file.PlaylistEntries[1].Path);
Assert.AreEqual(playlist.PlaylistEntries[1].Title, file.PlaylistEntries[1].Title);
Assert.AreNotEqual(playlist.PlaylistEntries[1].Album, file.PlaylistEntries[1].Album);
Assert.AreNotEqual(playlist.PlaylistEntries[1].AlbumArtist, file.PlaylistEntries[1].AlbumArtist);
Assert.AreEqual(playlist.PlaylistEntries[2].Path, file.PlaylistEntries[2].Path);
Assert.AreEqual(playlist.PlaylistEntries[2].Title, file.PlaylistEntries[2].Title);
Assert.AreEqual(playlist.PlaylistEntries[2].Album, file.PlaylistEntries[2].Album);
Assert.AreEqual(playlist.PlaylistEntries[2].AlbumArtist, file.PlaylistEntries[2].AlbumArtist);
}
static void Main(string[] args)
{
var iTunesXml = @"C:\Users\matth\Music\iTunes\iTunes Music Library.xml";
var library = new ITunesLibrary(iTunesXml);
var tracks = library.Tracks;
// returns all tracks in the iTunes Library
var albums = library.Albums;
// returns all albums in the iTunes Library
var playlists = library.Playlists;
foreach (var playlist in playlists.Where(p => p.Tracks != null && p.Tracks.Count() != 0))
{
Console.WriteLine(playlist.Name);
var serviceCollection = new ServiceCollection();
serviceCollection.AddLogging();
var playlistOutput = new M3uPlaylist
{
IsExtended = true
};
foreach (var track in playlist.Tracks)
{
if (track.Location != null)
{
playlistOutput.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Album = track.Album,
AlbumArtist = track.Artist,
Path = track.Location.Replace("file://localhost/D:/iTunesMedia/Music", "..").Replace("%20", " "),
Title = track.Name
});
}
}
var content = new M3uContent();
string text = content.ToText(playlistOutput);
File.WriteAllText(@"\\192.168.1.2\music\playlists\" + playlist.Name + ".m3u", text);
}
}
private async void Save_Click(object sender, RoutedEventArgs e)
{
M3uContent playlistContent = new M3uContent();
M3uPlaylist savePlaylist = new M3uPlaylist
{
IsExtended = false
};
foreach (Item item in Playlist)
{
savePlaylist.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Path = item.FilePath
});
}
string textPlaylist = playlistContent.Create(savePlaylist);
var savePicker = new FileSavePicker
{
SuggestedStartLocation = PickerLocationId.DocumentsLibrary,
SuggestedFileName = "New Playlist"
};
savePicker.FileTypeChoices.Add("M3U Playlist", new List <string>()
{
".m3u"
});
StorageFile playlistFile = await savePicker.PickSaveFileAsync();
if (playlistFile != null)
{
CachedFileManager.DeferUpdates(playlistFile);
await FileIO.WriteTextAsync(playlistFile, textPlaylist);
FileUpdateStatus status = await CachedFileManager.CompleteUpdatesAsync(playlistFile);
if (status == FileUpdateStatus.Complete)
{
ToastNotificationManager.CreateToastNotifier().Show(new ToastNotificationBuilder().Build(
"vMix List Maker",
"Playlist " + playlistFile.Name + " saved successfully!"
));
}
}
}
public static List <ChannelInfo> LoadChannellist()
{
string localFilePath = "ASTRA_19_2E.m3u";
if (!File.Exists(localFilePath))
{
new WebClient().DownloadFile(_m3uUrl, localFilePath);
}
M3uContent content = new M3uContent();
M3uPlaylist playlist = content.GetFromStream(File.OpenRead(localFilePath));
List <ChannelInfo> channelList = playlist.PlaylistEntries.Select(item => new ChannelInfo()
{
Name = item.Title, Url = item.Path
}).ToList();
return(channelList);
}
public async Task <string> GetStreamUrl(string url)
{
var m3UContent = new M3uContent();
var request = (HttpWebRequest)WebRequest.Create(url);
var response = (HttpWebResponse)await request.GetResponseAsync();
var stream = response.GetResponseStream();
var playlist = m3UContent.GetFromStream(stream);
if (!playlist.PlaylistEntries.Any())
{
return(null);
}
var entry = playlist.PlaylistEntries[0];
return(entry.Path);
}
public static Playlist Read(string playlistPath)
{
if (!File.Exists(playlistPath))
{
return(null);
}
var ext = Path.GetExtension(playlistPath).ToLower();
var playlistStream = new FileStream(playlistPath, FileMode.Open);
IEnumerable <BasePlaylistEntry> playlistEntries;
switch (ext)
{
case ".pls":
playlistEntries = new PlsContent().GetFromStream(playlistStream).PlaylistEntries;
break;
case ".m3u":
playlistEntries = new M3uContent().GetFromStream(playlistStream).PlaylistEntries;
break;
case ".m3u8":
playlistEntries = new M3u8Content().GetFromStream(playlistStream).PlaylistEntries;
break;
case ".wpl":
playlistEntries = new WplContent().GetFromStream(playlistStream).PlaylistEntries;
break;
case ".zpl":
playlistEntries = new ZplContent().GetFromStream(playlistStream).PlaylistEntries;
break;
default:
throw new InvalidOperationException("unknown playlist format");
}
playlistStream.Close();
if (playlistEntries.Count() == 0)
{
return(null);
}
return(new Playlist(playlistEntries.Select(e => e.Path)));
}
public ObservableCollection <MusicFileTag> LoadPlaylist(string filePath)
{
ObservableCollection <MusicFileTag> NewMusicFileTags = new ObservableCollection <MusicFileTag>();
Stream fileContentStream = new FileStream(filePath, FileMode.Open);
M3uContent content = new M3uContent();
M3uPlaylist playlist = content.GetFromStream(fileContentStream);
List <string> paths = playlist.GetTracksPaths();
foreach (var file in paths)
{
MusicFileTag newMusicFile = AddFile(file);
if (newMusicFile != null)
{
NewMusicFileTags.Add(newMusicFile);
}
}
return(NewMusicFileTags);
}
public IPlaylist Load(string filePath)
{
IPlaylist playlist = null;
M3uPlaylist m3uPlaylistBase = null;
if (string.IsNullOrWhiteSpace(filePath) || !File.Exists(filePath))
{
return(null);
}
using (StreamReader sr = new StreamReader(filePath))
{
M3uContent content = new M3uContent();
m3uPlaylistBase = content.GetFromStream(sr.BaseStream);
}
m3uPlaylistBase.Path = filePath;
playlist = MapToDomain(m3uPlaylistBase);
return(playlist);
}
public void GetFromStream_ReadVLCPlaylistExtendedAndCompareWithObject_Equal()
{
var entry = new M3uPlaylistEntry
{
Album = null,
AlbumArtist = null,
Duration = TimeSpan.FromSeconds(304),
Path = "Aimer/春はゆく - marie/01 - 春はゆく.flac",
Title = "Aimer - 春はゆく",
};
var content = new M3uContent();
using (var stream = Helpers.ReadStream("PlaylistVLC.m3u"))
{
var file = content.GetFromStream(stream);
var fileEntry = file.PlaylistEntries[0];
Assert.AreEqual(entry.Path, fileEntry.Path);
Assert.AreEqual(entry.Title, fileEntry.Title);
}
}
public void Create_CreatePlaylistExtendedAndCompareWithFile_Equal()
{
M3uContent content = new M3uContent();
M3uPlaylist playlist = new M3uPlaylist();
playlist.IsExtended = true;
playlist.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Album = "",
AlbumArtist = "",
Duration = TimeSpan.FromSeconds(254),
Path = @"D:\Muzyka\Andrea Bocelli\04 Chiara.mp3",
Title = "Andrea Bocelli - Chiara",
});
var entry = new M3uPlaylistEntry()
{
Album = null,
AlbumArtist = null,
Duration = TimeSpan.FromSeconds(-1),
Path = @"D:\Muzyka\Andrea Bocelli\01 Con Te Partiro.mp3",
Title = "Andrea Bocelli - Con Te Partiro",
};
entry.CustomProperties.Add("EXTVLCOPT", "network-caching=1000");
playlist.PlaylistEntries.Add(entry);
playlist.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Album = "AndreaBocelli",
AlbumArtist = "Andrea Bocelli",
Duration = TimeSpan.FromSeconds(-1),
Path = @"D:\Muzyka\Andrea Bocelli\04 E Chiove.mp3",
Title = "Andrea Bocelli - E Chiove",
});
string created = content.ToText(playlist);
string fromFile = Helpers.Read("PlaylistExt.m3u");
Assert.AreEqual(created, fromFile);
}
public void Open()
{
OpenFileDialog openFileDialog1 = new OpenFileDialog();
openFileDialog1.Filter = "Playlist files (*.m3u)|*.m3u|All files (*.*)|*.*";
openFileDialog1.Title = "Open Playlist";
openFileDialog1.ShowDialog();
if (openFileDialog1.FileName != "")
{
Clear();
M3uPlaylist playlist = new M3uPlaylist
{
IsExtended = true
};
M3uContent content = new M3uContent();
using (System.IO.FileStream fs = (System.IO.FileStream)openFileDialog1.OpenFile())
{
playlist = content.GetFromStream(fs);
// Remove final null char at end of last entry
playlist.PlaylistEntries.Last().Path = playlist.PlaylistEntries.Last().Path.Substring(0, playlist.PlaylistEntries.Last().Path.Length - 1);
Files = new ObservableCollection <PlaylistEntry>();
foreach (M3uPlaylistEntry file in playlist.PlaylistEntries)
{
Files.Add(new PlaylistEntry(new Song(file.Path)));
}
}
playlist = null;
}
}
private R <Playlist, LocalStr> GetPlaylistContent(Stream stream, string url, Uid owner, string mime = null)
{
string name = null;
List <PlaylistItem> items;
mime = mime.ToLowerInvariant();
url = url.ToLowerInvariant();
string anyId = mime ?? url;
switch (anyId)
{
case ".m3u":
{
var parser = new M3uContent();
var list = parser.GetFromStream(stream);
items = new List <PlaylistItem>(
from e in list.PlaylistEntries
select new PlaylistItem(new AudioResource(e.Path, e.Title, ResolverFor)));
break;
}
case ".m3u8":
case "application/mpegurl":
case "application/x-mpegurl":
case "audio/mpegurl":
case "audio/x-mpegurl":
case "application/vnd.apple.mpegurl":
case "application/vnd.apple.mpegurl.audio":
{
var parser = new M3u8Content();
var list = parser.GetFromStream(stream);
items = new List <PlaylistItem>(
from e in list.PlaylistEntries
select new PlaylistItem(new AudioResource(e.Path, e.Title, ResolverFor)));
break;
}
case ".pls":
case "audio/x-scpls":
case "application/x-scpls":
case "application/pls+xml":
{
var parser = new PlsContent();
var list = parser.GetFromStream(stream);
items = new List <PlaylistItem>(
from e in list.PlaylistEntries
select new PlaylistItem(new AudioResource(e.Path, e.Title, ResolverFor)));
break;
}
case ".wpl":
{
var parser = new WplContent();
var list = parser.GetFromStream(stream);
items = new List <PlaylistItem>(
from e in list.PlaylistEntries
select new PlaylistItem(new AudioResource(e.Path, e.TrackTitle, ResolverFor)));
name = list.Title;
break;
}
case ".zpl":
{
var parser = new ZplContent();
var list = parser.GetFromStream(stream);
items = new List <PlaylistItem>(
from e in list.PlaylistEntries
select new PlaylistItem(new AudioResource(e.Path, e.TrackTitle, ResolverFor)));
name = list.Title;
break;
}
// ??
case "application/jspf+json":
// ??
case "application/xspf+xml":
default:
return(new LocalStr(strings.error_media_file_not_found)); // TODO Loc "media not supported"
}
if (string.IsNullOrEmpty(name))
{
var index = url.LastIndexOfAny(new[] { '\\', '/' });
name = index >= 0 ? url.Substring(index) : url;
}
return(new Playlist(name, owner, Enumerable.Empty <Uid>(), items));
}
private void SavePlaylistFile(Playlist item)
{
// this is probably best done as a metadata provider
// saving a file over itself will require some work to prevent this from happening when not needed
var playlistPath = item.Path;
var extension = Path.GetExtension(playlistPath);
if (string.Equals(".wpl", extension, StringComparison.OrdinalIgnoreCase))
{
var playlist = new WplPlaylist();
foreach (var child in item.GetLinkedChildren())
{
var entry = new WplPlaylistEntry()
{
Path = NormalizeItemPath(playlistPath, child.Path),
TrackTitle = child.Name,
AlbumTitle = child.Album
};
var hasAlbumArtist = child as IHasAlbumArtist;
if (hasAlbumArtist != null)
{
entry.AlbumArtist = hasAlbumArtist.AlbumArtists.FirstOrDefault();
}
var hasArtist = child as IHasArtist;
if (hasArtist != null)
{
entry.TrackArtist = hasArtist.Artists.FirstOrDefault();
}
if (child.RunTimeTicks.HasValue)
{
entry.Duration = TimeSpan.FromTicks(child.RunTimeTicks.Value);
}
playlist.PlaylistEntries.Add(entry);
}
string text = new WplContent().ToText(playlist);
File.WriteAllText(playlistPath, text);
}
if (string.Equals(".zpl", extension, StringComparison.OrdinalIgnoreCase))
{
var playlist = new ZplPlaylist();
foreach (var child in item.GetLinkedChildren())
{
var entry = new ZplPlaylistEntry()
{
Path = NormalizeItemPath(playlistPath, child.Path),
TrackTitle = child.Name,
AlbumTitle = child.Album
};
var hasAlbumArtist = child as IHasAlbumArtist;
if (hasAlbumArtist != null)
{
entry.AlbumArtist = hasAlbumArtist.AlbumArtists.FirstOrDefault();
}
var hasArtist = child as IHasArtist;
if (hasArtist != null)
{
entry.TrackArtist = hasArtist.Artists.FirstOrDefault();
}
if (child.RunTimeTicks.HasValue)
{
entry.Duration = TimeSpan.FromTicks(child.RunTimeTicks.Value);
}
playlist.PlaylistEntries.Add(entry);
}
string text = new ZplContent().ToText(playlist);
File.WriteAllText(playlistPath, text);
}
if (string.Equals(".m3u", extension, StringComparison.OrdinalIgnoreCase))
{
var playlist = new M3uPlaylist();
playlist.IsExtended = true;
foreach (var child in item.GetLinkedChildren())
{
var entry = new M3uPlaylistEntry()
{
Path = NormalizeItemPath(playlistPath, child.Path),
Title = child.Name,
Album = child.Album
};
var hasAlbumArtist = child as IHasAlbumArtist;
if (hasAlbumArtist != null)
{
entry.AlbumArtist = hasAlbumArtist.AlbumArtists.FirstOrDefault();
}
if (child.RunTimeTicks.HasValue)
{
entry.Duration = TimeSpan.FromTicks(child.RunTimeTicks.Value);
}
playlist.PlaylistEntries.Add(entry);
}
string text = new M3uContent().ToText(playlist);
File.WriteAllText(playlistPath, text);
}
if (string.Equals(".m3u8", extension, StringComparison.OrdinalIgnoreCase))
{
var playlist = new M3uPlaylist();
playlist.IsExtended = true;
foreach (var child in item.GetLinkedChildren())
{
var entry = new M3uPlaylistEntry()
{
Path = NormalizeItemPath(playlistPath, child.Path),
Title = child.Name,
Album = child.Album
};
var hasAlbumArtist = child as IHasAlbumArtist;
if (hasAlbumArtist != null)
{
entry.AlbumArtist = hasAlbumArtist.AlbumArtists.FirstOrDefault();
}
if (child.RunTimeTicks.HasValue)
{
entry.Duration = TimeSpan.FromTicks(child.RunTimeTicks.Value);
}
playlist.PlaylistEntries.Add(entry);
}
string text = new M3u8Content().ToText(playlist);
File.WriteAllText(playlistPath, text);
}
if (string.Equals(".pls", extension, StringComparison.OrdinalIgnoreCase))
{
var playlist = new PlsPlaylist();
foreach (var child in item.GetLinkedChildren())
{
var entry = new PlsPlaylistEntry()
{
Path = NormalizeItemPath(playlistPath, child.Path),
Title = child.Name
};
if (child.RunTimeTicks.HasValue)
{
entry.Length = TimeSpan.FromTicks(child.RunTimeTicks.Value);
}
playlist.PlaylistEntries.Add(entry);
}
string text = new PlsContent().ToText(playlist);
File.WriteAllText(playlistPath, text);
}
}
public void GetFromStream_ReadPlaylistExtendedAndCompareWithObject_Equal()
{
M3uContent content = new M3uContent();
M3uPlaylist playlist = new M3uPlaylist();
playlist.IsExtended = true;
playlist.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Album = "",
AlbumArtist = "",
Duration = TimeSpan.FromSeconds(254),
Path = @"D:\Muzyka\Andrea Bocelli\04 Chiara.mp3",
Title = "Andrea Bocelli - Chiara",
});
var entry = new M3uPlaylistEntry()
{
Album = null,
AlbumArtist = null,
Duration = TimeSpan.FromSeconds(-1),
Path = @"D:\Muzyka\Andrea Bocelli\01 Con Te Partiro.mp3",
Title = "Andrea Bocelli - Con Te Partiro",
};
entry.CustomProperties.Add("EXTVLCOPT", "network-caching=1000");
playlist.PlaylistEntries.Add(entry);
playlist.PlaylistEntries.Add(new M3uPlaylistEntry()
{
Album = "AndreaBocelli",
AlbumArtist = "Andrea Bocelli",
Duration = TimeSpan.FromSeconds(-1),
Path = @"D:\Muzyka\Andrea Bocelli\04 E Chiove.mp3",
Title = "Andrea Bocelli - E Chiove",
});
using (var stream = Helpers.ReadStream("PlaylistExt.m3u"))
{
var file = content.GetFromStream(stream);
Assert.AreEqual(playlist.IsExtended, file.IsExtended);
Assert.AreEqual(playlist.PlaylistEntries.Count, file.PlaylistEntries.Count);
Assert.AreEqual(playlist.PlaylistEntries[0].Path, file.PlaylistEntries[0].Path);
Assert.AreEqual(playlist.PlaylistEntries[0].Title, file.PlaylistEntries[0].Title);
Assert.AreEqual(playlist.PlaylistEntries[0].Album, file.PlaylistEntries[0].Album);
Assert.AreEqual(playlist.PlaylistEntries[0].AlbumArtist, file.PlaylistEntries[0].AlbumArtist);
Assert.AreEqual(playlist.PlaylistEntries[1].Path, file.PlaylistEntries[1].Path);
Assert.AreEqual(playlist.PlaylistEntries[1].Title, file.PlaylistEntries[1].Title);
Assert.AreNotEqual(playlist.PlaylistEntries[1].Album, file.PlaylistEntries[1].Album);
Assert.AreNotEqual(playlist.PlaylistEntries[1].AlbumArtist, file.PlaylistEntries[1].AlbumArtist);
Assert.IsNull(playlist.PlaylistEntries[1].Album);
Assert.AreEqual("", file.PlaylistEntries[1].Album);
Assert.AreEqual(playlist.PlaylistEntries[1].CustomProperties.Count(), file.PlaylistEntries[1].CustomProperties.Count());
Assert.AreEqual(playlist.PlaylistEntries[1].CustomProperties.Last().Key, file.PlaylistEntries[1].CustomProperties.Last().Key);
Assert.AreEqual(playlist.PlaylistEntries[1].CustomProperties.Last().Value, file.PlaylistEntries[1].CustomProperties.Last().Value);
Assert.AreEqual(playlist.PlaylistEntries[2].Path, file.PlaylistEntries[2].Path);
Assert.AreEqual(playlist.PlaylistEntries[2].Title, file.PlaylistEntries[2].Title);
Assert.AreEqual(playlist.PlaylistEntries[2].Album, file.PlaylistEntries[2].Album);
Assert.AreEqual(playlist.PlaylistEntries[2].AlbumArtist, file.PlaylistEntries[2].AlbumArtist);
}
}
