using System;

using System.Data;

using System.Configuration;

using System.Web;

using System.Data.OleDb;

using System.Collections;

/// <summary>

/// AcceHelper 的摘要说明

/// </summary>

public static class AccessHelper

{

    //数据库连接字符串

    //public static readonly string conn = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + HttpContext.Current.Request.PhysicalApplicationPath + System.Configuration.ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString;

    public static readonly string conn = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=zjmTemp.mdb";

    // 用于缓存参数的HASH表

    private static Hashtable parmCache = Hashtable.Synchronized(new Hashtable());

    /// <summary>

    ///  给定连接的数据库用假设参数执行一个sql命令（不返回数据集）

    /// </summary>

    /// <param name="connectionString">一个有效的连接字符串</param>

    /// <param name="commandText">存储过程名称或者sql命令语句</param>

    /// <param name="commandParameters">执行命令所用参数的集合</param>

    /// <returns>执行命令所影响的行数</returns>

    public static int ExecuteNonQuery(string connectionString, string cmdText, params OleDbParameter[] commandParameters)

    {

        try

        {

            OleDbCommand cmd = new OleDbCommand();

            using (OleDbConnection conn = new OleDbConnection(connectionString))

            {

                PrepareCommand(cmd, conn, null, cmdText, commandParameters);

                int val = cmd.ExecuteNonQuery();

                cmd.Parameters.Clear();

                return val;

            }

        }

        catch (Exception ex)

        {

            throw ex;

        }

    }

    /// <summary>

    /// 用现有的数据库连接执行一个sql命令（不返回数据集）

    /// </summary>

    /// <remarks>

    ///举例:

    ///  int result = ExecuteNonQuery(connString, "PublishOrders", new OleDbParameter("@prodid", 24));

    /// </remarks>

    /// <param name="conn">一个现有的数据库连接</param>

    /// <param name="commandText">存储过程名称或者sql命令语句</param>

    /// <param name="commandParameters">执行命令所用参数的集合</param>

    /// <returns>执行命令所影响的行数</returns>

    public static int ExecuteNonQuery(OleDbConnection connection, string cmdText, params OleDbParameter[] commandParameters)

    {

        OleDbCommand cmd = new OleDbCommand();

        PrepareCommand(cmd, connection, null, cmdText, commandParameters);

        int val = cmd.ExecuteNonQuery();

        cmd.Parameters.Clear();

        return val;

    }

    /// <summary>

    ///使用现有的SQL事务执行一个sql命令（不返回数据集）

    /// </summary>

    /// <remarks>

    ///举例:

    ///  int result = ExecuteNonQuery(trans, "PublishOrders", new OleDbParameter("@prodid", 24));

    /// </remarks>

    /// <param name="trans">一个现有的事务</param>

    /// <param name="commandText">存储过程名称或者sql命令语句</param>

    /// <param name="commandParameters">执行命令所用参数的集合</param>

    /// <returns>执行命令所影响的行数</returns>

    public static int ExecuteNonQuery(OleDbTransaction trans, string cmdText, params OleDbParameter[] commandParameters)

    {

        OleDbCommand cmd = new OleDbCommand();

        PrepareCommand(cmd, trans.Connection, trans, cmdText, commandParameters);

        int val = cmd.ExecuteNonQuery();

        cmd.Parameters.Clear();

        return val;

    }

    /// <summary>

    /// 用执行的数据库连接执行一个返回数据集的sql命令

    /// </summary>

    /// <remarks>

    /// 举例:

    ///  OleDbDataReader r = ExecuteReader(connString, "PublishOrders", new OleDbParameter("@prodid", 24));

    /// </remarks>

    /// <param name="connectionString">一个有效的连接字符串</param>

    /// <param name="commandText">存储过程名称或者sql命令语句</param>

    /// <param name="commandParameters">执行命令所用参数的集合</param>

    /// <returns>包含结果的读取器</returns>

    public static OleDbDataReader ExecuteReader(string connectionString, string cmdText, params OleDbParameter[] commandParameters)

    {

        //创建一个SqlCommand对象

        OleDbCommand cmd = new OleDbCommand();

        //创建一个SqlConnection对象

        OleDbConnection conn = new OleDbConnection(connectionString);

        //在这里我们用一个try/catch结构执行sql文本命令/存储过程，因为如果这个方法产生一个异常我们要关闭连接，因为没有读取器存在，

        //因此commandBehaviour.CloseConnection 就不会执行

        try

        {

            //调用 PrepareCommand 方法，对 SqlCommand 对象设置参数

            PrepareCommand(cmd, conn, null, cmdText, commandParameters);

            //调用 SqlCommand  的 ExecuteReader 方法

            OleDbDataReader reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);

            //清除参数

            cmd.Parameters.Clear();

            return reader;

        }

        catch

        {

            //关闭连接，抛出异常

            conn.Close();

            throw;

        }

    }

    /// <summary>

    /// 返回一个DataSet数据集

    /// </summary>

    /// <param name="connectionString">一个有效的连接字符串</param>

    /// <param name="cmdText">存储过程名称或者sql命令语句</param>

    /// <param name="commandParameters">执行命令所用参数的集合</param>

    /// <returns>包含结果的数据集</returns>

    public static DataSet ExecuteDataSet(string connectionString, string cmdText, params OleDbParameter[] commandParameters)

    {

        //创建一个SqlCommand对象，并对其进行初始化

        OleDbCommand cmd = new OleDbCommand();

        using (OleDbConnection conn = new OleDbConnection(connectionString))

        {

            PrepareCommand(cmd, conn, null, cmdText, commandParameters);

            //创建SqlDataAdapter对象以及DataSet

            OleDbDataAdapter da = new OleDbDataAdapter(cmd);

            DataSet ds = new DataSet();

            try

            {

                //填充ds

                da.Fill(ds);

                // 清除cmd的参数集合

                cmd.Parameters.Clear();

                //返回ds

                return ds;

            }

            catch

            {

                //关闭连接，抛出异常

                conn.Close();

                throw;

            }

        }

    }

    /// <summary>

    /// 用指定的数据库连接字符串执行一个命令并返回一个数据集的第一列

    /// </summary>

    /// <remarks>

    ///例如:

    ///  Object obj = ExecuteScalar(connString, "PublishOrders", new OleDbParameter("@prodid", 24));

    /// </remarks>

    ///<param name="connectionString">一个有效的连接字符串</param>

    /// <param name="commandText">存储过程名称或者sql命令语句</param>

    /// <param name="commandParameters">执行命令所用参数的集合</param>

    /// <returns>用 Convert.To{Type}把类型转换为想要的 </returns>

    public static object ExecuteScalar(string connectionString, string cmdText, params OleDbParameter[] commandParameters)

    {

        OleDbCommand cmd = new OleDbCommand();

        using (OleDbConnection connection = new OleDbConnection(connectionString))

        {

            PrepareCommand(cmd, connection, null, cmdText, commandParameters);

            object val = cmd.ExecuteScalar();

            cmd.Parameters.Clear();

            return val;

        }

    }

    /// <summary>

    /// 用指定的数据库连接执行一个命令并返回一个数据集的第一列

    /// </summary>

    /// <remarks>

    /// 例如:

    ///  Object obj = ExecuteScalar(connString, "PublishOrders", new OleDbParameter("@prodid", 24));

    /// </remarks>

    /// <param name="conn">一个存在的数据库连接</param>

    /// <param name="commandText">存储过程名称或者sql命令语句</param>

    /// <param name="commandParameters">执行命令所用参数的集合</param>

    /// <returns>用 Convert.To{Type}把类型转换为想要的 </returns>

    public static object ExecuteScalar(OleDbConnection connection, string cmdText, params OleDbParameter[] commandParameters)

    {

        OleDbCommand cmd = new OleDbCommand();

        PrepareCommand(cmd, connection, null, cmdText, commandParameters);

        object val = cmd.ExecuteScalar();

        cmd.Parameters.Clear();

        return val;

    }

    /// <summary>

    /// 将参数集合添加到缓存

    /// </summary>

    /// <param name="cacheKey">添加到缓存的变量</param>

    /// <param name="cmdParms">一个将要添加到缓存的sql参数集合</param>

    public static void CacheParameters(string cacheKey, params OleDbParameter[] commandParameters)

    {

        parmCache[cacheKey] = commandParameters;

    }

    /// <summary>

    /// 找回缓存参数集合

    /// </summary>

    /// <param name="cacheKey">用于找回参数的关键字</param>

    /// <returns>缓存的参数集合</returns>

    public static OleDbParameter[] GetCachedParameters(string cacheKey)

    {

        OleDbParameter[] cachedParms = (OleDbParameter[])parmCache[cacheKey];

        if (cachedParms == null)

            return null;

        OleDbParameter[] clonedParms = new OleDbParameter[cachedParms.Length];

        for (int i = 0, j = cachedParms.Length; i < j; i++)

            clonedParms = (OleDbParameter[])((ICloneable)cachedParms).Clone();

        return clonedParms;

    }

    /// <summary>

    /// 准备执行一个命令

    /// </summary>

    /// <param name="cmd">sql命令</param>

    /// <param name="conn">Sql连接</param>

    /// <param name="trans">Sql事务</param>

    /// <param name="cmdText">命令文本,例如：Select * from Products</param>

    /// <param name="cmdParms">执行命令的参数</param>

    private static void PrepareCommand(OleDbCommand cmd, OleDbConnection conn, OleDbTransaction trans, string cmdText, OleDbParameter[] cmdParms)

    {

        //判断连接的状态。如果是关闭状态，则打开

        if (conn.State != ConnectionState.Open)

            conn.Open();

        //cmd属性赋值

        cmd.Connection = conn;

        cmd.CommandText = cmdText;

        //是否需要用到事务处理

        if (trans != null)

            cmd.Transaction = trans;

        cmd.CommandType = CommandType.Text;

        //添加cmd需要的存储过程参数

        if (cmdParms != null)

        {

            foreach (OleDbParameter parm in cmdParms)

                cmd.Parameters.Add(parm);

        }

    }

}

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Windows.Forms;

using System.Data.OleDb;

using System.IO;

namespace WindowsFormsTest

{

    public partial class Form1 : Form

    {

        public Form1()

        {

            InitializeComponent();

        }

        /// <summary>

        ///

        /// </summary>

        /// <param name="Buffer">byte[]</param>

        public static Image BufferToImage(byte[] Buffer)

        {

            if (Buffer == null || Buffer.Length == 0) { return null; }

            byte[] data = null;

            Image oImage = null;

            Bitmap oBitmap = null;

            //建立副本

            data = (byte[])Buffer.Clone();

            try

            {

                MemoryStream oMemoryStream = new MemoryStream(Buffer);

                oMemoryStream.Position = 0;

                oImage = System.Drawing.Image.FromStream(oMemoryStream);

                oBitmap = new Bitmap(oImage);

            }

            catch

            {

                throw;

            }

            return oBitmap;

        }

        /// <summary>

        /// 将图片转换为byte[]

        /// </summary>

        /// <param name="Image"></param>

        /// <param name="imageFormat"></param>

        public static byte[] ImageToBuffer(Image Image, System.Drawing.Imaging.ImageFormat imageFormat)

        {

            if (Image == null) { return null; }

            byte[] data = null;

            using (MemoryStream oMemoryStream = new MemoryStream())

            {

                //建立副本

                using (Bitmap oBitmap = new Bitmap(Image))

                {

                    //儲存圖片到 MemoryStream 物件，並且指定儲存影像之格式

                    oBitmap.Save(oMemoryStream, imageFormat);

                    //設定資料流位置

                    oMemoryStream.Position = 0;

                    //設定 buffer 長度

                    data = new byte[oMemoryStream.Length];

                    //將資料寫入 buffer

                    oMemoryStream.Read(data, 0, Convert.ToInt32(oMemoryStream.Length));

                    //將所有緩衝區的資料寫入資料流

                    oMemoryStream.Flush();

                }

            }

            return data;

        }

        private void button1_Click(object sender, EventArgs e)

        {

            //Parameters.Add("@Image", OleDbType.VarBinary, pic.Length).Value = pic;

            byte[] pic = ImageToBuffer(pictureBox1.Image, System.Drawing.Imaging.ImageFormat.Jpeg);

            OleDbParameter[] pars = new OleDbParameter[2];

            OleDbParameter p = new OleDbParameter("@right", OleDbType.VarBinary, pic.Length);

            p.Value = pic;

            pars[0] = p;

            OleDbParameter p1 = new OleDbParameter("@left", OleDbType.VarBinary, pic.Length);

            p1.Value = pic;

            pars[1] = p1;

            int i = AccessHelper.ExecuteNonQuery(AccessHelper.conn, "insert into zjm([right],[left]) values(@right,@left)", pars);

        }

        private void button2_Click(object sender, EventArgs e)

        {

        }

        private void button2_Click_1(object sender, EventArgs e)

        {

            OleDbDataReader sdr=AccessHelper.ExecuteReader(AccessHelper.conn, "select [left] from zjm where id="+this.textBox1.Text);

            sdr.Read();

            byte[] pic = (byte[])sdr[0];

            sdr.Close();

            this.pictureBox2.Image = BufferToImage(pic);

        }

    }

}