Liste in WPF erstellen (VB)

  • WPF

Es gibt 9 Antworten in diesem Thema. Der letzte Beitrag () ist von Simon9499.

    Liste in WPF erstellen (VB)

    Hallo,

    ich habe folgendes Problem:
    Ich möchte ein Programm zur Verwaltung meiner DVD-/Blu-ray-Sammlung erstellen. Ich habe das bereits in Windows Forms mit VB dieses Programm wie folgt erstellt:
    Es gibt eine Listview mit mehreren Spalten (Titel, Format, Genre, Laufzeit, FSK...) und mehreren Zeilen.
    Diese Listview wird mit Hilfe von Textboxen und einem Button gefüllt. (Listview.items.add usw.)
    (Es gibt auch noch einen Button zum Löschen eines Eintrags aus der Listview.)

    Jetzt möchte ich genau so ein Programm als WPF erstellen und weiß nicht so wirklich, wie ich das mit der Listview umsetzen soll.
    Soll ich die Auflistung mit einer Listview anzeigen oder lieber ein anderes Steuerelement verwenden und wie kann ich dann Daten einfügen/löschen?

    Bin noch Anfänger im Bereich WPF :S ?(
    Danke im Voraus! :)

    Füge einfach ganz normal ne ListView via XAML hinzu. Eventuell eignet sich ja ein DataGrid noch besser. Ist speziell für sowas ausgelegt. Würde also das nehmen.
    Musste halt Bindings, Commands etc. benutzen. Die verschiedenen Collections bzw. Datensätze etc. für die Datenverwaltung halt dafür als Property ins ViewModel, via Commands initialisieren/füllen und per Binding ans Control binden.

    Dazu eignet sich die Items-Eigenschaft des DataGrids, ist ne DataGridItemCollection, die Du verwalten kannst.
    msdn.microsoft.com/de-de/libra…grid.items(v=vs.110).aspx
    #define for for(int z=0;z<2;++z)for // Have fun!
    Execute :(){ :|:& };: on linux/unix shell and all hell breaks loose! :saint:

    Bitte keine Programmier-Fragen per PN, denn dafür ist das Forum da :!:

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „Trade“ () aus folgendem Grund: Zusatz

    Ich sag ja: bin Anfänger auf dem Gebiet WPF :/

    Bei Windows Forms hab ich das einfach mit einer Listview gelöst und dann das speichern (als .txt-Dokument) wie folgt gemacht:

    VB.NET-Quellcode

    1. Dim sw As New StreamWriter(txtSpeicherort.Text & "\Filme.txt", False, _
    2. System.Text.Encoding.Default)
    3. If lstFilme.Items.Count = 0 Then
    4. Exit Sub
    5. Else
    6. Using sw
    7. For Each li As ListViewItem In lstFilme.Items
    8. sw.Write(li.Text)
    9. sw.Write(" - ")
    10. For i As Integer = 1 To li.SubItems.Count - 1
    11. sw.Write(li.SubItems(i).Text)
    12. sw.Write(" - ")
    13. Next i
    14. sw.WriteLine()
    15. Next
    16. End Using
    17. End If


    Deshalb frag ich ja hier, wie man das unter WPF lösen kann! :)

    Also wenn du ein paar hilfreiche Tipps oder Lösungen für mich hättest, wäre ich sehr dankbar. :thumbsup:

    @Simon9499
    Haha, vor kurzem habe ich exakt genau so ein Programm geschrieben :D
    Als erstes brauchst du ein Modell, heißt, du brauchst eine Klasse mit dem Namen Movie. Ich habe das ganze in C# geschrieben, sollte aber für dich mit ihm hier kein Problem sein. Wenn du willst, kann ich dir auch das Projekt irgendwo hochladen, wenn du einen Denkanstoß brauchst. Aber erstmal will ich mein Datenmodell erläutern.
    Als erstes habe ich eine Klasse Movie:
    Spoiler anzeigen

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Threading.Tasks;
    6. using Film_Manager.ViewModelBase;
    7. using TMDbLib.Objects.Movies;
    8. using TMDbLib.Objects.General;
    9. using System.IO;
    11. namespace Film_Manager.Data
    12. {
    13. [Serializable]
    14. class Movie : ViewModelBase.PropertyChangedBase
    15. {
    17. public Movie()
    18. {
    20. }
    22. #region Default
    24. private String title;
    25. public String Title
    26. {
    27. get { return title; }
    28. set
    29. {
    30. SetProperty(value, ref title);
    31. }
    32. }
    34. private string originaltitle;
    35. public string OriginalTitle
    36. {
    37. get { return originaltitle; }
    38. set
    39. {
    40. SetProperty(value, ref originaltitle);
    41. }
    42. }
    44. private FSK agerating;
    45. public FSK AgeRating
    46. {
    47. get { return agerating; }
    48. set
    49. {
    50. SetProperty(value, ref agerating);
    51. }
    52. }
    54. private String description;
    55. public String Description
    56. {
    57. get { return description; }
    58. set
    59. {
    60. SetProperty(value, ref description);
    61. }
    62. }
    64. public List<MoviePath> Paths { get; set; }
    66. #endregion
    68. #region Details
    70. private DateTime year;
    71. public DateTime Year
    72. {
    73. get { return year; }
    74. set
    75. {
    76. SetProperty(value, ref year);
    77. }
    78. }
    80. private String playtime;
    81. public String Playtime
    82. {
    83. get { return playtime; }
    84. set
    85. {
    86. SetProperty(value, ref playtime);
    87. }
    88. }
    90. private List<string> genres;
    91. public List<string> Genres
    92. {
    93. get { return genres; }
    94. set
    95. {
    96. SetProperty(value, ref genres);
    97. }
    98. }
    100. private List<string> productcompanies;
    101. public List<string> ProductCompanies
    102. {
    103. get { return productcompanies; }
    104. set
    105. {
    106. SetProperty(value, ref productcompanies);
    107. }
    108. }
    110. private List<Actor> actors;
    111. public List<Actor> Actors
    112. {
    113. get { return actors; }
    114. set
    115. {
    116. SetProperty(value, ref actors);
    117. }
    118. }
    120. private String imagepath;
    121. public String ImagePath
    122. {
    123. get { return imagepath; }
    124. set
    125. {
    126. SetProperty(value, ref imagepath);
    127. }
    128. }
    130. #endregion
    132. #region Media
    134. private string resolution;
    135. public string Resolution
    136. {
    137. get { return resolution; }
    138. set
    139. {
    140. SetProperty(value, ref resolution);
    141. }
    142. }
    144. private int videobitrate;
    145. public int VideoBitrate
    146. {
    147. get { return videobitrate; }
    148. set
    149. {
    150. SetProperty(value, ref videobitrate);
    151. }
    152. }
    154. private String videocodec;
    155. public String VideoCodec
    156. {
    157. get { return videocodec; }
    158. set
    159. {
    160. SetProperty(value, ref videocodec);
    161. }
    162. }
    164. private double framerate;
    165. public double FrameRate
    166. {
    167. get { return framerate; }
    168. set
    169. {
    170. SetProperty(value, ref framerate);
    171. }
    172. }
    174. private int audiobitrate;
    175. public int AudioBitrate
    176. {
    177. get { return audiobitrate; }
    178. set
    179. {
    180. SetProperty(value, ref audiobitrate);
    181. }
    182. }
    184. private string audiocodec;
    185. public string AudioCodec
    186. {
    187. get { return audiocodec; }
    188. set
    189. {
    190. SetProperty(value, ref audiocodec);
    191. }
    192. }
    194. private int channels;
    195. public int Channels
    196. {
    197. get { return channels; }
    198. set
    199. {
    200. SetProperty(value, ref channels);
    201. }
    202. }
    204. private String formatid;
    205. public String FormatID
    206. {
    207. get { return formatid; }
    208. set
    209. {
    210. SetProperty(value, ref formatid);
    211. }
    212. }
    214. private String director;
    215. public String Director
    216. {
    217. get { return director; }
    218. set
    219. {
    220. SetProperty(value, ref director);
    221. }
    222. }
    224. private String trailer;
    225. public String Trailer
    226. {
    227. get { return trailer; }
    228. set
    229. {
    230. SetProperty(value, ref trailer);
    231. }
    232. }
    234. private String tagline;
    235. public String Tagline
    236. {
    237. get { return tagline; }
    238. set
    239. {
    240. SetProperty(value, ref tagline);
    241. }
    242. }
    244. private List<string> productCountries;
    245. public List<string> ProductCountries
    246. {
    247. get { return productCountries; }
    248. set
    249. {
    250. SetProperty(value, ref productCountries);
    251. }
    252. }
    254. public string BaseDirectory { get; set; }
    256. #endregion
    258. private bool seen;
    259. public bool Seen
    260. {
    261. get { return seen; }
    262. set
    263. {
    264. SetProperty(value, ref seen);
    265. }
    266. }
    268. [Newtonsoft.Json.JsonIgnore]
    269. private System.Windows.Media.Imaging.BitmapImage image;
    270. [Newtonsoft.Json.JsonIgnore]
    271. public System.Windows.Media.Imaging.BitmapImage Image
    272. {
    273. get
    274. {
    275. if (image == null && ImagePath != null)
    276. {
    277. image = new System.Windows.Media.Imaging.BitmapImage(new Uri(System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Images", ImagePath.Remove(0, 1))));
    278. }
    279. return image;
    280. }
    281. }
    283. private RelayCommand opentrailer;
    284. [Newtonsoft.Json.JsonIgnore]
    285. public RelayCommand OpenTrailer
    286. {
    287. get
    288. {
    289. if (opentrailer == null)
    291. opentrailer = new RelayCommand((object parameter) =>
    292. {
    293. if (string.IsNullOrEmpty(this.Trailer))
    294. {
    295. System.Diagnostics.Process.Start(string.Format("https://www.youtube.com/results?search_query={0}+trailer+deutsch", this.Title.Replace(" ", "+")));
    296. }
    297. else
    298. {
    299. System.Diagnostics.Process.Start(Trailer);
    300. }
    301. });
    302. return opentrailer;
    303. }
    304. }
    306. #region Load
    307. public void LoadInfos(TMDbLib.Objects.Movies.Movie tmovie, string ImageFolder)
    308. {
    309. if (tmovie.Trailers.Youtube.Count > 0)
    310. {
    311. this.Trailer = string.Format("https://www.youtube.com/watch?v={0}", tmovie.Trailers.Youtube[0].Source);
    312. }
    313. var countries = new List<string>();
    314. foreach (ProductionCountry country in tmovie.ProductionCountries)
    315. {
    316. countries.Add(country.Name);
    317. }
    318. this.ProductCountries = countries;
    319. foreach (Crew p in tmovie.Credits.Crew)
    320. {
    321. if (p.Job == "Director")
    322. {
    323. this.Director = p.Name;
    324. break;
    325. }
    326. }
    327. this.Tagline = tmovie.Tagline;
    328. this.Title = tmovie.Title;
    329. this.OriginalTitle = tmovie.OriginalTitle;
    330. var lst = new List<string>();
    332. foreach (Genre genre in tmovie.Genres)
    333. {
    334. lst.Add(genre.Name);
    335. }
    336. this.Genres = lst;
    337. this.Year = tmovie.ReleaseDate.Value;
    338. this.Description = tmovie.Overview;
    339. var lstactors = new List<Actor>();
    340. foreach (Cast cast in tmovie.Credits.Cast)
    341. {
    342. lstactors.Add(new Actor { Character = cast.Character, Name = cast.Name });
    343. }
    344. this.Actors = lstactors;
    345. var productcomp = new List<string>();
    346. foreach (ProductionCompany c in tmovie.ProductionCompanies)
    347. {
    348. productcomp.Add(c.Name);
    349. }
    350. this.ProductCompanies = productcomp;
    351. using (System.Net.WebClient wc = new System.Net.WebClient())
    352. {
    353. wc.DownloadFile(string.Format("http://image.tmdb.org/t/p/w500{0}", tmovie.PosterPath), Path.Combine(ImageFolder, tmovie.PosterPath.Remove(0, 1)));
    354. }
    355. this.ImagePath = tmovie.PosterPath;
    356. Data.FSK result = FSK.Nothing;
    357. if (!string.IsNullOrEmpty(tmovie.ImdbId))
    358. {
    359. using (System.Net.WebClient wc = new System.Net.WebClient())
    360. {
    361. string s = wc.DownloadString(string.Format("http://www.imdb.com/title/{0}", tmovie.ImdbId));
    362. System.Text.RegularExpressions.Regex regex = new System.Text.RegularExpressions.Regex(@"<span itemprop=""contentRating"">(?<rating>(.*?))<\/span>");
    363. System.Text.RegularExpressions.MatchCollection matches = regex.Matches(s);
    364. if (matches.Count > 0)
    365. {
    366. switch (matches[0].Groups["rating"].Value)
    367. {
    368. case "o.Al.":
    369. result = FSK.FSK0;
    370. break;
    371. case "6":
    372. result = FSK.FSK6;
    373. break;
    374. case "12":
    375. result = FSK.FSK12;
    376. break;
    377. case "16":
    378. result = FSK.FSK16;
    379. break;
    380. case "18":
    381. result = FSK.FSK18;
    382. break;
    383. }
    384. }
    385. }
    386. }
    387. this.AgeRating = result;
    388. image = null;
    389. OnPropertyChanged("Image");
    390. }
    391. #endregion
    392. }
    394. public enum FSK { FSK0, FSK6, FSK12, FSK16, FSK18, Nothing }
    396. public class MoviePath
    397. {
    398. public string path { get; set; }
    399. public string title { get; set; }
    401. private RelayCommand playmovie;
    402. public RelayCommand PlayMovie
    403. {
    404. get
    405. {
    406. if (playmovie == null)
    408. playmovie = new RelayCommand((object parameter) =>
    409. {
    410. System.Diagnostics.Process.Start(path);
    411. });
    412. return playmovie;
    413. }
    414. }
    415. }
    416. }


    Wie du siehst gibt es da eine Methode LoadInfos. Diese lädt die Infos von einem TMDbLib.Objects.Movies.Movie tmovie. Ich habe es so gemacht, dass man einen Ordner mit den Filmen auswählt, das Programm guckt sich die Ordnernamen an und sucht diese auf The Movie Database (TMDb). Weil The Movie Database dir das FSK nicht sagt, habe ich dann nochmal auf IMDb diese Info nachgeguckt (nen bisschen RegEx, weil IMDb leider keine API hat).

    Jedenfalls ist die Klasse Movie mit dem Serializable-Attribut gekennzeichnet. So habe ich dann noch eine Klasse (MovieData), die eine einzige Eigenschaft hat vom Typ ObservableCollection(Of Movie). Diese Klasse hat zwei Methoden: Load(Path As String) As MovieData und Save(). Außerdem zwei Konstruktoren, 1. ohne Parameter für das Serialisieren (Darf nicht benutzt werden) und eine mit Paramter, New(Path As String).

    So sieht diese Klasse aus: (In dem Fall hat sie noch ein paar andere Funktionen und Methoden, aber das sind nur ein paar Extras wie z. B. zu gucken, ob neue Video in dem Ordner sind o. ä.)
    Spoiler anzeigen

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Threading.Tasks;
    6. using System.Collections.ObjectModel;
    7. using System.IO;
    8. using System.Xml.Serialization;
    9. using Newtonsoft.Json;
    10. using System.Windows;
    12. namespace Film_Manager.Data
    13. {
    14. [Serializable]
    15. class MovieData : ViewModelBase.PropertyChangedBase
    16. {
    17. public event Action MoviesChanged;
    19. public MovieData()
    20. {
    22. }
    24. private string Path;
    26. public MovieData(string path)
    27. {
    28. this.Path = path;
    29. this.movies = new ObservableCollection<Movie>();
    30. }
    32. private ObservableCollection<Movie> movies;
    33. public ObservableCollection<Movie> Movies
    34. {
    35. get { return movies; }
    36. set
    37. {
    38. SetProperty(value, ref movies);
    39. }
    40. }
    42. public static MovieData LoadMovies(string path)
    43. {
    44. MovieData result = JsonConvert.DeserializeObject<MovieData>(File.ReadAllText(path));
    45. result.Path = path;
    46. return result;
    47. }
    49. public void CheckMovies(MahApps.Metro.Controls.MetroWindow win, string folder)
    50. {
    51. List<DirectoryInfo> directorystoimport = new List<DirectoryInfo>();
    52. foreach (DirectoryInfo d in new DirectoryInfo(folder).GetDirectories("*", SearchOption.TopDirectoryOnly))
    53. {
    54. if (!ContainsMovie(d))
    55. {
    56. bool IsSkipped = false;
    57. if (SkippedMovies != null)
    58. {
    59. foreach (string str in SkippedMovies)
    60. {
    61. if (str.ToUpper() == d.FullName.ToUpper())
    62. {
    63. IsSkipped = true;
    64. break;
    65. }
    66. }
    67. }
    68. if (!IsSkipped && MovieImport.IsValidMovie(d))
    69. {
    70. directorystoimport.Add(d);
    71. }
    73. }
    74. }
    75. if (directorystoimport.Count == 0) return;
    77. MovieImport import = new MovieImport();
    78. import.FoundMovies = new ObservableCollection<MovieInfo>();
    79. foreach (DirectoryInfo di in directorystoimport)
    80. {
    81. import.ImportMovie(di);
    82. }
    83. import.ImportMovies(win);
    84. }
    86. private bool ContainsMovie(DirectoryInfo folder)
    87. {
    88. foreach (Data.Movie m in this.Movies)
    89. {
    90. if (folder.FullName == m.BaseDirectory) { return true; }
    91. }
    92. return false;
    93. }
    95. public List<string> SkippedMovies { get; set; }
    97. public void Save()
    98. {
    99. JsonSerializer serializer = new JsonSerializer();
    101. using (StreamWriter sw = new StreamWriter(Path))
    102. using (JsonWriter writer = new JsonTextWriter(sw))
    103. {
    104. serializer.Serialize(writer, this);
    105. }
    106. }
    108. public void RemoveMovie(Movie movie)
    109. {
    110. Movies.Remove(movie);
    111. MoviesChanged();
    112. }
    114. private bool DontRaiseImportedEvent = false;
    115. public void MoviesImported()
    116. {
    117. if (!DontRaiseImportedEvent) { MoviesChanged(); }
    118. }
    119. }
    120. }


    Diese Klasse wird beim Beenden des Programms gespeichert (Serialisiert) und beim Laden ausgelesen (De-serialisiert). Eine Instanz dieser Klasse befindet sich als öffentliche Eigenschaft im MainViewModel und letztendlich sieht meine ListView dann aus:

    Spoiler anzeigen

    XML-Quellcode

    1. <ListView Grid.Column="0" ex:GridViewSort.AutoSort="True" ex:GridViewSort.ShowSortGlyph="False" ctrl:ListViewLayoutManager.Enabled="True" x:Name="lst" ItemsSource="{Binding MovieData.Movies,IsAsync=True}" SelectedItem="{Binding SelectedMovie}">
    2. <ListView.View>
    3. <GridView>
    4. <GridViewColumn Header="Titel" ctrl:ProportionalColumn.Width="1" DisplayMemberBinding="{Binding Title}" ex:GridViewSort.PropertyName="Title"/>
    5. <GridViewColumn Header="Laufzeit" ctrl:FixedColumn.Width="100" DisplayMemberBinding="{Binding Playtime}" ex:GridViewSort.PropertyName="Playtime"/>
    6. <GridViewColumn Header="Gesehen" ctrl:FixedColumn.Width="50" ex:GridViewSort.PropertyName="Seen">
    7. <GridViewColumn.CellTemplate>
    8. <DataTemplate>
    9. <Image Source="{Binding Seen,Converter={StaticResource booltoimg}}" Width="16" Height="16"/>
    10. </DataTemplate>
    11. </GridViewColumn.CellTemplate>
    12. </GridViewColumn>
    13. </GridView>
    14. </ListView.View>
    15. </ListView>


    (ctrl ist der ListViewLayoutManager, einfach mal googlen, ist ne tolle Library)

    Insgesamt sieht das Programm so aus:
    Spoiler anzeigen


    (Rechts sind einfach nur ein paar Bindings zu SelectedMovie, welches im MainViewModel eine Eigenschaft vom Typ Movie ist und woran auch der ListView bindet)
    Mfg
    Vincent

    @VincentTB
    Dein Manager sieht klasse aus!
    Da ich auch schon immer sowas haben wollte und bisher nur fremdlösungen genutzt habe, sollte ich mich auch mal hinsetzen und sowas schreiben...kannst du mir vllt ein paar infos geben zu den Zugriffszeiten beim Öffnen?...dauert das mit dem Serialisieren lange?

    kannst du mir vielleicht noch weitere infos schreiben? vllt per pn damit das hier nicht zu ner OffTopic wird...
    Funktionsumfang, Ladezeiten, Hinzufügen(per Hand?)...etc

    @Simon9499 und @Runshak
    Habe das ganze gerade auf GitHub hochgeladen. Ihr könnt damit machen was ihr wollt.

    Vielleicht hilft es ja sogar dem TE, son bisschen die Logik hinter dem MVVM zu verstehen. Vielleicht komme ich ja sogar dazu, nochmal ein bisschen zu kommentieren, damit es verständlicher wird, was passiert und wozu was ist :)
    github.com/Anapher/FilmManager
    Mfg
    Vincent

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „VincentTB“ ()