Auslesen einer Excel-Tabelle vereinfachen??

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Auslesen einer Excel-Tabelle vereinfachen??

    Hallo

    Das Programm an sich funktioniert soweit.
    -> Es liest Zellen aus einer Excel-Tabelle aus und soll diese in ein txt-Doc speichern.
    Vielleicht weiß einer eine Möglichkeit den Text zu vereinfachen.
    Und wie ich anschließend die Werte in eine txt.-datei schreiben kann.
    Und wie ich überprüfen kann, ob die nächste Spalte/Zeile leer ist.
    Ich hoffe mir kann jemand helfen!

    Dank schon mal

    Quellcode

    1. Microsoft.Office.Interop.Excel.Application excel = new Microsoft.Office.Interop.Excel.ApplicationClass();
    2. excel.Visible = false;
    3. object missing = Missing.Value;
    4. string fileName = Path.Combine(System.Windows.Forms.Application.StartupPath, tDateipfad.Name);
    5. Microsoft.Office.Interop.Excel.Workbook workbook = excel.Workbooks.Open(fileName, missing, missing, missing,
    6. missing, missing, missing, missing, missing, missing, missing, missing, missing,
    7. missing, missing);
    8. object sheet = excel.GetType().InvokeMember("ActiveSheet", BindingFlags.GetProperty, null, excel, new object[0]);
    9. StreamWriter myFile = new StreamWriter(tspeicherpfad.Name);
    10. string domain = "Domain";
    11. string wert = "Wert";
    12. string deutsch = "deutsch";
    13. string englisch = "englisch";
    14. //Domain
    15. object DomainA1 = sheet.GetType().InvokeMember("Range", BindingFlags.GetProperty | BindingFlags.OptionalParamBinding, null, sheet, new object[2] { "A1", Missing.Value });
    16. string dA1 = Convert.ToString(DomainA1.GetType().InvokeMember("Value", BindingFlags.GetProperty, null, DomainA1, new object[0]));
    17. if (dA1 != domain)
    18. {
    19. object DomainB1 = sheet.GetType().InvokeMember("Range", BindingFlags.GetProperty | BindingFlags.OptionalParamBinding, null, sheet, new object[2] { "B1", Missing.Value });
    20. string dB1 = Convert.ToString(DomainB1.GetType().InvokeMember("Value", BindingFlags.GetProperty, null, DomainB1, new object[0]));
    21. if (dB1 != domain)
    22. {
    23. object DomainC1 = sheet.GetType().InvokeMember("Range", BindingFlags.GetProperty | BindingFlags.OptionalParamBinding, null, sheet, new object[2] { "C1", Missing.Value });
    24. string dC1 = Convert.ToString(DomainC1.GetType().InvokeMember("Value", BindingFlags.GetProperty, null, DomainC1, new object[0]));
    25. if (dC1 != domain)
    26. {
    27. object DomainD1 = sheet.GetType().InvokeMember("Range", BindingFlags.GetProperty | BindingFlags.OptionalParamBinding, null, sheet, new object[2] { "D1", Missing.Value });
    28. string dD1 = Convert.ToString(DomainD1.GetType().InvokeMember("Value", BindingFlags.GetProperty, null, DomainD1, new object[0]));
    29. if (dD1 != domain)
    30. {
    31. object DomainE1 = sheet.GetType().InvokeMember("Range", BindingFlags.GetProperty | BindingFlags.OptionalParamBinding, null, sheet, new object[2] { "E1", Missing.Value });
    32. string dE1 = Convert.ToString(DomainE1.GetType().InvokeMember("Value", BindingFlags.GetProperty, null, DomainE1, new object[0]));
    33. if (dE1 != domain)
    34. {
    35. object DomainF1 = sheet.GetType().InvokeMember("Range", BindingFlags.GetProperty | BindingFlags.OptionalParamBinding, null, sheet, new object[2] { "F1", Missing.Value });
    36. string dF1 = Convert.ToString(DomainF1.GetType().InvokeMember("Value", BindingFlags.GetProperty, null, DomainF1, new object[0]));
    37. if (dF1 != domain)
    38. {
    39. object DomainG1 = sheet.GetType().InvokeMember("Range", BindingFlags.GetProperty | BindingFlags.OptionalParamBinding, null, sheet, new object[2] { "G1", Missing.Value });
    40. string dG1 = Convert.ToString(DomainG1.GetType().InvokeMember("Value", BindingFlags.GetProperty, null, DomainG1, new object[0]));
    41. if (dG1 != domain)
    42. {
    43. object DomainH1 = sheet.GetType().InvokeMember("Range", BindingFlags.GetProperty | BindingFlags.OptionalParamBinding, null, sheet, new object[2] { "H1", Missing.Value });
    44. string dH1 = Convert.ToString(DomainH1.GetType().InvokeMember("Value", BindingFlags.GetProperty, null, DomainH1, new object[0]));
    45. if (dH1 != domain)
    46. {
    47. MessageBox.Show("Domain nicht enthalten");
    48. }
    49. else
    50. {
    51. object domainH2 = sheet.GetType().InvokeMember("Range", BindingFlags.GetProperty | BindingFlags.OptionalParamBinding, null, sheet, new object[2] { "H2", Missing.Value });
    52. string doH2 = Convert.ToString(domainH2.GetType().InvokeMember("Value", BindingFlags.GetProperty, null, domainH2, new object[0]));
    53. if (doH2 == "") { goto NEXT; }
    54. ...bis H12
    55. }
    56. }
    57. else
    58. {
    59. object domainG2 = sheet.GetType().InvokeMember("Range", BindingFlags.GetProperty | BindingFlags.OptionalParamBinding, null, sheet, new object[2] { "G2", Missing.Value });
    60. string doG2 = Convert.ToString(domainG2.GetType().InvokeMember("Value", BindingFlags.GetProperty, null, domainG2, new object[0]));
    61. if (doG2 == "") { goto NEXT; }
    62. ...bis G12
    63. }
    64. }
    65. else
    66. {
    67. object domainF2 = sheet.GetType().InvokeMember("Range", BindingFlags.GetProperty | BindingFlags.OptionalParamBinding, null, sheet, new object[2] { "F2", Missing.Value });
    68. string doF2 = Convert.ToString(domainF2.GetType().InvokeMember("Value", BindingFlags.GetProperty, null, domainF2, new object[0]));
    69. if (doF2 == "") { goto NEXT; }
    70. ...bis F12
    71. }
    72. }
    73. else
    74. {
    75. object domainE2 = sheet.GetType().InvokeMember("Range", BindingFlags.GetProperty | BindingFlags.OptionalParamBinding, null, sheet, new object[2] { "E2", Missing.Value });
    76. string doE2 = Convert.ToString(domainE2.GetType().InvokeMember("Value", BindingFlags.GetProperty, null, domainE2, new object[0]));
    77. if (doE2 == "") { goto NEXT; }
    78. ...bis E12
    79. }
    80. }
    81. else
    82. {
    83. object domainD2 = sheet.GetType().InvokeMember("Range", BindingFlags.GetProperty | BindingFlags.OptionalParamBinding, null, sheet, new object[2] { "D2", Missing.Value });
    84. string doD2 = Convert.ToString(domainD2.GetType().InvokeMember("Value", BindingFlags.GetProperty, null, domainD2, new object[0]));
    85. if (doD2 == "") { goto NEXT; }
    86. ...bis D12
    87. }
    88. }
    89. else
    90. {
    91. object domainC2 = sheet.GetType().InvokeMember("Range", BindingFlags.GetProperty | BindingFlags.OptionalParamBinding, null, sheet, new object[2] { "C2", Missing.Value });
    92. string doC2 = Convert.ToString(domainC2.GetType().InvokeMember("Value", BindingFlags.GetProperty, null, domainC2, new object[0]));
    93. if (doC2 == "") { goto NEXT; }
    94. ...bis C12
    95. }
    96. }
    97. else
    98. {
    99. object domainB2 = sheet.GetType().InvokeMember("Range", BindingFlags.GetProperty | BindingFlags.OptionalParamBinding, null, sheet, new object[2] { "B2", Missing.Value });
    100. string doB2 = Convert.ToString(domainB2.GetType().InvokeMember("Value", BindingFlags.GetProperty, null, domainB2, new object[0]));
    101. if (doB2 == "") { goto NEXT; }
    102. ...bis B12
    103. }
    104. }
    105. else
    106. {
    107. object domainA2 = sheet.GetType().InvokeMember("Range", BindingFlags.GetProperty | BindingFlags.OptionalParamBinding, null, sheet, new object[2] { "A2", Missing.Value });
    108. string doA2 = Convert.ToString(domainA2.GetType().InvokeMember("Value", BindingFlags.GetProperty, null, domainA2, new object[0]));
    109. if (doA2 == "") { goto NEXT; }
    110. ...bis A12
    111. object domainA12 = sheet.GetType().InvokeMember("Range", BindingFlags.GetProperty | BindingFlags.OptionalParamBinding, null, sheet, new object[2] { "A12", Missing.Value });
    112. string doA12 = Convert.ToString(domainA12.GetType().InvokeMember("Value", BindingFlags.GetProperty, null, domainA12, new object[0]));
    113. if (doA12 == "") { goto NEXT; }
    114. }
    115. NEXT:
    116. //Wert
    117. NEXT1:
    118. //deutsch
    119. NEXT2:
    120. //englisch
    121. //3 weitere Abfragen (das selbe)
    122. End:
    123. //Werte in txt-Datei schreiben
    124. myFile.Close();
    125. excel.Quit();
    Alles anzeigen

  • Hallo Hexe145.

    Nur mal so als Anregung. Wäre es nicht einfacher die exel-datei mit einem StreamReader zu öffnen und zeilenweise den Stream auszulesen. Die Spalten werden mit eine einem ; getrennt und das Zeilenende wird mit einem Environment.NewLine gekennzeichnet.

    Um in eine Textdatei zu schreiben benutzt du am besten einen StreamWriter

    Deine anderen Fragen dürften sich von selbst lösen, wenn du einen StreamReader zum auslesen der exel-datei und einen StreamWriter zum schreiben in eine Textdatei benutzt ;)
    ~ rock on ~

  • Hallo IchRogue81.

    Vielen Dank für deine schnelle Antwort.
    Habe es gleich mal so ausprobiert.
    Leider ist das ganze sehr schwer zu lesen.
    Im Anhang schicke ich dir mal das Ergebnis.

    Vll. kennt jemand noch ne andere Lösung.

    Bin für alle Vorschläge offen.
    Vll. noch ein kleiner Hinweis: Die Excel-Tabellen sind nicht immer gleich!
    Dateien

    • Test1.txt

      (17,68 kB, 504 mal heruntergeladen, zuletzt: )

  • Hi,

    das Thema ist älter, ich weiss... Leichenschädung, aber noch als kleine Ergänzung die ich gerne genannt haben möchte:

    Ich finde, dass ein Problem vorgeben sollte in welcher Sprache man es löst und nicht umgekehrt, denn was bringt es den Heldentod zu sterben? Damit meine ich, dass ich deinen Code für totalen Overkill empfinde. In anderen Sprachen wäre das ein vier-Zeiler und hier so ein Monster an Code nur um etwas auszulesen und neu abzuspeichern? :S

    Tipp: R dafür nutzen ;)

  • Wenn du das Thema nochmal eröffnest... Ich weiß nicht genau welches Excel ihr so benutzt aber das von Microsoft speichert seine Daten normalerweise nicht in Semikolon-separierten Dateien ab. Excel kann das zwar, man kann aber nicht davon ausgehen immer solche Dateien bekommen. Also ist der Ansatz es mit VSTO und .NET zumachen vollkommen richtig gewählt und kaum in 4 Zeilen zu schaffen. Außerdem würde es keinen Sinn machen, CSV-Dateien einlesen und dann so wieder wegzuspeichern - so eine Frage würde doch hier niemand stellen?
    Der Code der hier verwendet wird ist natürlich allerunterste Schublade, mit GOTOs programmiert man seit Jahren nichts mehr. Ich würde jetzt ohne es ausführen zu wollen behaupten, dass es mehr Faktoren gibt die Wahl der Programmiersprache beeinflussen als die problemorientiertheit. In diesem Fall kann man natürlich wenn man pfiffig ist auf die Idee kommen den Excel-CSV Exporter mittels VSTO anzusprechen, dann können es vielleicht doch mit biegen ein brechen ein 4-Zeiler werden.


    P.S. Also wenn wir schon bei Problemorientierung sind. R hat einen völlig anderen Fokus und ich denke es gehört so ziemlich mit zu dem ungünstigsten Was man auswählen könnte.
    ~ mfg SeBa

    Ich beantworte keine PMs zu Computer-/Programmierproblemen. Bitte wendet euch an das entsprechende Forum.

    [Blockierte Grafik: http://i.creativecommons.org/l/by-sa/3.0/80x15.png]