Comic-Konvertierung

  • Ich habe zwei kleine Strukturen (die sich später in Klassen ändern könnten), die in generische Listen geladen werden. Ich verlange das Laden der Listen. Kann dies besser oder objektorientierter durchgeführt werden?

    Sie werden feststellen, dass ich die MS Enterprise-Bibliothek für den Datenzugriff auf eine SqlCe-Datenbank verwende.

    Ich suche nur nach Meinungen zu diesem Code. Gibt es einen effizienteren Weg, um das zu tun, was ich bisher geschrieben habe? Mein Ziel ist es, den Code so effizient und klein wie möglich zu gestalten und dabei trotzdem wartbar und erweiterbar zu sein.

      public class ConversionUtility
    {
    
        private List<ComicBook> _books;
        private List<ComicPublisher> _publishers;
    
        private void Load()
        {
            try
            {
                _books = GetBooks();
                _publishers = GetPublishers();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
    
        public void PerformConversion()
        {
            Load();
    
           //still working on this
    
        }
    
    
        private List<ComicPublisher> GetPublishers()
        {
            List<ComicPublisher> tmp = new List<ComicPublisher>();
    
            Database db = EnterpriseLibraryContainer.Current.GetInstance<Database>("CeConnectionString");
    
            IDataReader rdr = db.ExecuteReader(CommandType.Text, "SELECT * FROM Publisher");
    
            while (rdr.Read())
            {
                tmp.Add(new ComicPublisher { Id = (int)rdr["PublisherId"], Name = rdr["PublisherName"].ToString() });
            }
            return tmp;
    
        }
    
        private List<ComicBook> GetBooks()
        {
            List<ComicBook> tmp = new List<ComicBook>();
    
            Database db = EnterpriseLibraryContainer.Current.GetInstance<Database>("CeConnectionString");
    
            IDataReader rdr = db.ExecuteReader(CommandType.Text, "SELECT * FROM Book");
    
            while (rdr.Read())
            {
                tmp.Add(new ComicBook { Id = (int)rdr["BookId"], Title = rdr["Title"].ToString(), Company = rdr["Company"].ToString() });
            }
    
            return tmp;
    
        }
    
    }
    
    
    public struct ComicPublisher
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }
    
    public struct ComicBook
    {
        public int Id { get; set; }
        public string Title { get; set; }
        public string Company { get; set; }
    }
     
    31 March 2016
    Jamal
3 answers
  • Erstens:

    Schließen Sie Ihre DataReader !!!


    Zweitens:

    Vielleicht möchten Sie Boilerplate-Code wie folgt abstrahieren:

       Database db = EnterpriseLibraryContainer.Current.GetInstance<Database>("CeConnectionString");
      IDataReader rdr = db.ExecuteReader(CommandType.Text, "SELECT * FROM Book");
     

    In einige Hilfsmethoden.

    26 November 2011
    Vagnerr
  • Ich ziehe vor, dass struct s unveränderlich ist und interface -Typen verwendet, wenn sie verfügbar sind. Daher muss ich (einschließlich meines Kommentars in die Frage) Folgendes präsentieren:

     public sealed class ConversionUtility
    {
        private IList<ComicBook> _books;
        private IList<ComicPublisher> _publishers;
    
        public void PerformConversion()
        {
            this.Load();
    
            // still working on this
        }
    
        private void Load()
        {
            try
            {
                this._books = this.GetBooks();
                this._publishers = this.GetPublishers();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
    
        private IList<ComicPublisher> GetPublishers()
        {
            IList<ComicPublisher> tmp = new List<ComicPublisher>();
    
            Database db = EnterpriseLibraryContainer.Current.GetInstance<Database>("CeConnectionString");
    
            using (IDataReader rdr = db.ExecuteReader(CommandType.Text, "SELECT * FROM Publisher"))
            {
                while (rdr.Read())
                {
                    tmp.Add(new ComicPublisher((int)rdr["PublisherId"], rdr["PublisherName"].ToString()));
                }
            }
    
            return tmp;
        }
    
        private IList<ComicBook> GetBooks()
        {
            IList<ComicBook> tmp = new List<ComicBook>();
    
            Database db = EnterpriseLibraryContainer.Current.GetInstance<Database>("CeConnectionString");
    
            using (IDataReader rdr = db.ExecuteReader(CommandType.Text, "SELECT * FROM Book"))
            {
                while (rdr.Read())
                {
                    tmp.Add(new ComicBook((int)rdr["BookId"], rdr["Title"].ToString(), rdr["Company"].ToString()));
                }
            }
    
            return tmp;
        }
    }
    
    public struct ComicPublisher
    {
        private readonly int id;
        private readonly string name;
    
        public ComicPublisher(int id, string name)
        {
            this.id = id;
            this.name = name;
        }
    
        public int Id { get { return this.id; } }
        public string Name { get { return this.name; } }
    }
    
    public struct ComicBook
    {
        private readonly int id;
        private readonly string title;
        private readonly string company;
    
        public ComicBook(int id, string title, string company)
        {
            this.id = id;
            this.title = title;
            this.company = company;
        }
    
        public int Id { get { return this.id; } }
        public string Title { get { return this.title; } }
        public string Company { get { return this.company; } }
    }
     
    25 November 2011
    Jesse C. Slicer
  • Sie könnten dies zu einer generischen Methode machen. Wenn Sie Ihre Tische & amp; Klassen zu einem einheitlichen Format, dann wäre es sehr einfach:

     interface IThing
    {
        int Id {get;set;}
        string Name {get;set;}
        string DatabaseTableName {get;}
    }
    
    class GetThings<T> where T : IThing, new()
    {
        private List<T> GetItems()
        {
            var t = new T();
    
            List<T> tmp = new List<T>();
            Database db = EnterpriseLibraryContainer.Current.GetInstance<Database>("CeConnectionString");
            string query = String.Format("SELECT * FROM {0}", t.DatabaseTableName);
            IDataReader rdr = db.ExecuteReader(CommandType.Text, query);
    
            while (rdr.Read())
            {
                tmp.Add(new T { Id = (int)rdr["Id"], Name = rdr["Name"].ToString() });
            }
            return tmp;
        }
    }
     

    und Ihre Klassen müssen die IThing-Schnittstelle implementieren . Wenn Sie keine Schnittstelle verwenden möchten, werden die Dinge unordentlicher, und eine Überlegung und das Abgleichen von Eigenschaften sind erforderlich.

    Nachdem dies gesagt wurde, glaube ich nicht, dass es das Schreiben wert ist generische Klassen für zwei Strukturen.

    25 November 2011
    Anthony K