using (sqlConnection connection = new sqlConnection(Con.ConnectionString))
{
		connection.Open();
		sql.sqlCommand command = connection.CreateCommand();
		command.CommandText = SQL;
		using (sqlDataReader res = command.ExecuteReader())
		{
				while (res.Read())
                                ....
						
		}
}

public class BaseModelFactory<TEntity, TContext>
        where TEntity : class,IEntry, new()
        where TContext : DbContext, new()
    {
        string _connectionstring;
        DbContext _context;
        AsyncCallback _callback;

public BindingList<TEntity> GetSqlQueryData(bool addemptyrow, string sqltext, params object[] args)
        {
            _newitem = null;
            try
            {
                if (BaseContext != null)
                {
                    BaseContext.Dispose();
                    BaseContext = null;
                }
                BaseContext.Database.Connection.ConnectionString = _connectionstring;
                BaseContext.Set<TEntity>().SqlQuery(sqltext, args).ToList<TEntity>();
                if (addemptyrow)
                    AddNewItem(args);
                return BaseContext.Set<TEntity>().Local.ToBindingList();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                return null;
            }
        }

DbContext BaseContext
        {
            get
            {
                if (_context == null) _context = new TContext();
                return _context;
            }
            set
            {
                _context = value;
            }
        }

public bool SaveData()
        {
            List<TEntity> updateditems = new List<TEntity>();
            if (_callback != null)
            {
                BaseContext.Configuration.AutoDetectChangesEnabled = false;
            
                foreach (TEntity item in BaseContext.Set<TEntity>().Local.ToBindingList())
                {
                    if (BaseContext.Entry(item).State == EntityState.Modified || BaseContext.Entry(item).State == EntityState.Added)
                    {
                        updateditems.Add(item);
                    }
                }
                BaseContext.Configuration.AutoDetectChangesEnabled = true;
           }
            try
            {
                BaseContext.Database.Connection.ConnectionString = _connectionstring;
                bool haschanges = BaseContext.ChangeTracker.HasChanges();
                int baseContextSaveChanges = BaseContext.SaveChanges();
                foreach (TEntity item in updateditems)
                {
                    IAsyncResult callbackitem = item as IAsyncResult;
                    if (_callback != null && callbackitem != null)
                    {
                        _callback(callbackitem);
                    }
                }
                return (baseContextSaveChanges > 0 && haschanges) || !haschanges;
            }
            catch (DbUpdateConcurrencyException ex)
            {
                foreach (var item in ex.Entries)
                { CancelItem(item.Entity as TEntity); }
                UserMessanger.WarningUser(Resource.UpdateConcurrencyExceptionMessage);
                return true;
            }
            catch (Exception ex)
            {
                if (ex.InnerException != null)
                    UserMessanger.WarningUser(ex.ToString());
                return false;
            }
            finally
            {
            }
        }

[SRC C#]BaseContext.SaveChanges();

BaseContext.SaveChanges();

context.ИмяСущностиТаблица.Add(НоваяСущность)

context.ИмяСущностиТаблица.Add(НоваяСущность)

BaseContext.Set<TEntity>().Local.Add(item);