В LINQ-SQL перенеситесь, DataContext является оператором использования - недостатки профессионалов

Я зависит от сложности вашего уровня данных. Если каждый вызов является простым одиночным запросом, тогда каждый вызов может быть заключен в Использование как в вашем вопросе, и это будет нормально.

Если, с другой стороны, ваш уровень данных может ожидать несколько последовательных вызовов от бизнес-уровня, вам придется многократно создавать / удалять DataContext для каждой более крупной последовательности вызовов. не идеал.

Я создал объект уровня данных как IDisposible. Когда он создается, создается DataContext (или, на самом деле, после первого вызова метода), а когда объект уровня данных удаляется, он закрывается и удаляет DataContext.

вот как это выглядит:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Configuration;

namespace PersonnelDL
{
    public class PersonnelData : IDisposable
    {
        #region DataContext management
        /// <summary>
        /// Create common datacontext for all data routines to the DB
        /// </summary>
        private PersonnelDBDataContext _data = null;
        private PersonnelDBDataContext Data
        {
            get
            {
                if (_data == null)
                {
                    _data = new PersonnelDBDataContext(ConfigurationManager.ConnectionStrings["PersonnelDB"].ToString());
                    _data.DeferredLoadingEnabled = false; // no lazy loading
                    //var dlo = new DataLoadOptions(); // dataload options go here
                }
                return _data;
            }
        }

        /// <summary>
        /// close out data context
        /// </summary>
        public void Dispose()
        {
            if (_data != null)
                _data.Dispose();
        }
        #endregion

        #region DL methods
        public Person GetPersonByID(string userid)
        {
            return Data.Persons.FirstOrDefault(p => p.UserID.ToUpper().Equals(userid.ToUpper()));
        }

        public List<Person> GetPersonsByIDlist(List<string> useridlist)
        {
            var ulist = useridlist.Select(u => u.ToUpper().Trim()).ToList();
            return Data.Persons.Where(p => ulist.Contains(p.UserID.ToUpper())).ToList();
        }

        // more methods...
        #endregion
    }
}

Ну, это IDisposable, так что, думаю, это неплохая идея. Люди из MSFT говорили, что они сделали DataContexts настолько легкими, насколько это возможно, чтобы вы могли создавать их с безрассудством, так что вы, вероятно, не много выиграете, хотя.....

В одном конкретном приложении я столкнулся с тем, что без обертывания DataContext в using блок, объем используемой памяти продолжал увеличиваться, так как живые объекты не освобождались для GC. Например, в следующем примере, если я держу ссылку на объект List

DBDataContext db = new DBDataContext()
var qs = 
    from x in db.Tables
    where x.Id == someId
    select x;

return qs.toList();

foreach(q in qs)
{
    process(q);
    // cannot dispose datacontext here as the 2nd iteration 
    // will throw datacontext already disposed exception 
    // while accessing the entity of q in process() function
    //db.Dispose();
}

process(Table q)
{
    // access entity of q which uses deferred execution
    // if datacontext is already disposed, then datacontext 
    // already disposed exception is thrown
}

В этом примере я не могу утилизировать датаконтекст, потому что все экземпляры Table в переменной list qs **обмениваются одним и тем же датаконтекстом. После Dispose() обращение к сущности в process(Table q) вызывает исключение datacontext already disposed.

Уродливым ключом для меня было удаление всех ссылок на сущности для объектов q после цикла foreach. Лучшим способом, конечно, является использование оператора using.

Что касается моего опыта, я бы сказал, что лучше использовать оператор using.