代码之家  ›  专栏  ›  技术社区  ›  Greg

优化C语言中LINQ的简单用法#

  •  1
  • Greg  · 技术社区  · 14 年前

    我复制了我的代码的精简版本,最近重新编写了该版本,以使用LINQ访问数据库。

    然而,在我看来,LINQ非常简单,可能会被优化很多,特别是在第90行,在foreach循环中有一个LINQ语句。

    看看别人如何使用LINQ编写这个简单的任务,这真的很有帮助。事先谢谢!下面是我的源代码片段。

        // Model objects - these are to be populated from the database,
    // which has identical fields and table names.
    public class Element
    {
        public Element()
        {
            Translations = new Collection<Translation>();
        }
    
        public int Id { get; set; }
        public string Name { get; set; }
        public Collection<Translation> Translations { get; set; }
    
        public class Translation
        {
            public int Id { get; set; }
            public string Title { get; set; }
            public string Content { get; set; }
            public Language Lang { get; set; }
        }
    }
    public class Language
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Code { get; set; }
    }
    
    // Stripped-down functions for adding and loading Element
    // objects to/from the database:
    
    public static class DatabaseLoader
    {
        // Add method isn't too bulky, but I'm sure it could be optimised somewhere.
        public static void Add(string name, Collection<Translation> translations)
        {
            using (var db = DataContextFactory.Create<ElementContext>())
            {
                var dbElement = new Database.Element()
                {
                    Name = name
                };
                db.Elements.InsertOnSubmit(dbElement);
                // Must be submit so the dbElement gets it's Id set.
                db.SubmitChanges();
    
                foreach (var translation in translations)
                {
                    db.Translations.InsertOnSubmit(
                        new Database.Translation()
                            {
                                FK_Element_Id = dbElement.Id,
                                FK_Language_Id = translation.Lang.Id,
                                Title = translation.Title,
                                Content = translation.Content
                            });
                }
    
                // Submit all the changes outside the loop.
                db.SubmitChanges();
            }
        }
    
        // This method is really bulky, and I'd like to see the many separate linq
        // calls merged into one clever statement if possible (?).
        public static Element Load(int id)
        {
            using (var db = DataContextFactory.Create<ElementContext>())
            {
                // Get the database object of the relavent element.
                var dbElement =
                    (from e in db.Elements
                     where e.Id == id
                     select e).Single();
    
                // Find all the translations for the current element.
                var dbTranslations =
                    from t in db.Translations
                    where t.Fk_Element_Id == id
                    select t;
    
                // This object will be used to buld the model object.
                var trans = new Collection<Translation>();
    
                foreach (var translation in dbTranslations)
                {
                    // Build up the 'trans' variable for passing to model object.
                    // Here there is a linq statement for EVERY itteration of the
                    // foreach loop... not good (?).
                    var dbLanguage =
                        (from l in db.Languages
                         where l.Id == translation.FK_Language_Id
                         select l).Single();
    
                    trans.Add(new Translation()
                        {
                            Id = translation.Id,
                            Title = translation.Title,
                            Content = translation.Content,
                            Language = new Language()
                                {
                                    Id = dbLanguage.Id,
                                    Name = dbLanguage.Name, 
                                    Code = dbLanguage.Code
                                }
                        });
                }
    
                // The model object is now build up from the database (finally).
                return new Element()
                    {
                        Id = id,
                        Name = dbElement.Name,
                        Translations = trans
                    };
            }
        }
    }
    
    2 回复  |  直到 14 年前
        1
  •  1
  •   Ocelot20    14 年前

    使用一些组合的构造函数过于简单化:

    public static Element Load(int id)
    {
        using (var db = DataContextFactory.Create<ElementContext>())
        {
            var translations = from t in db.Translations
                               where t.Fk_Element_Id == id
                               join l in db.Languages on t.FK_Language_Id equals l.Id
                               select new Translation(t, l);
    
            return new Element(db.Elements.Where(x => x.Id == id).Single(), translations);
        }
    }
    
        2
  •  0
  •   Jimmy Hoffa    14 年前

    首先,我不喜欢这里所有的“new translation()bla=bla因为它们是代码块,所以我将它们放在一个方法中,您将对象交给它们,然后它们为您返回新的对象。

    Translations.InsertOnSubmit(CreateDatabaseTranslation(dbElement, translation));
    

    trans.Add(CreateTranslationWithLanguage(translation, dbLanguage));
    

    等等,无论你在哪里有这样的代码,它都会混淆你在这里所做的事情的可读性。