내부DB(Inner DB)는 MS ACCESS 파일(.mdb)
외부DB(External DB)는  MS SQL 2005 SERVER EXPRESS 를 기준으로 작성한 파일이다.
내부 DB를 사용 하기 위해선 파라미터의 names부분을 (:이름) 배열 형태로 작성하면 되고,
외부 DB를 사용 하기 위해선 파라미터의 names부분을 (@이름) 배열 형태로 작성하면 된다.

내부DB는 오피스 2003 이상 버전이 있다면 DB생성 및 편집이 가능하고,
외부DB는 상업적 이용도 무료다.(단, EXPRESS 에디션은 기능에 약간의 제한이 있긴하다.그러나 테스트 구축이나
작은 사이트를 운영하는데는 큰 무리 없다고 생각 된다.)

각각 constr과 ext_constr에 컨넥션 부분의 기본정보를 작성하고,
테이블이 필요 하다면 gettable,ext_gettable을 사용하고,
데이터만 필요 하다면 GetDatas,Ext_GetDatas를 사용하면 된다.



using System;
using System.Collections.Generic;
using System.Text;
using System.Data.OleDb;
using System.Data.Odbc;
using System.Data.Sql;
using System.Data.SqlClient;
using System.Data;
using System.IO;
using System.Collections;

namespace DUAL_DAO
{
    class DAO
    {
        static string constr = @"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=(accessDB경로);Persist Security Info=True";

        static OleDbDataReader rd;

        static OleDbDataAdapter da;

        static SqlDataReader sdr;

        static SqlDataAdapter sda;

        static string ext_constr = @"Data Source=(DB서버URL);User ID=(ID);Password=(PASSWORD)";

        DAO()
        {
           
        }

        public static bool connect_test()
        {
            bool state = false;
            SqlConnection conn = new SqlConnection(ext_constr);
            try
            {
                conn.Open();
                state = true;
                conn.Close();
            }
            catch (Exception)
            {
                state = false;
                if (conn.State == ConnectionState.Open) conn.Close();
            }
            return state;
        }

        public static DataTable gettable(string sql)
        {
            DataSet ds = new DataSet();

            da = new OleDbDataAdapter(sql,new OleDbConnection(constr));

            da.Fill(ds);

            return ds.Tables[0];
        }

        public static DataTable Ext_gettable(string sql)
        {
            DataSet ds = new DataSet();

            sda = new SqlDataAdapter(sql, new SqlConnection(ext_constr));

            sda.Fill(ds);

            return ds.Tables[0];
        }

        public static DataTable gettable(string sql,string[] names, object[] values)
        {
            DataSet ds = new DataSet();

            OleDbCommand odc = new OleDbCommand(sql, new OleDbConnection(constr));

            if (values != null)
            {
                for (int i = 0; i < values.Length; i++)
                {
                    odc.Parameters.AddWithValue(names[i], values[i]);
                }
            }

            odc.Connection.Open();

            da = new OleDbDataAdapter(odc);

            da.Fill(ds);

            return ds.Tables[0];
        }

        public static DataTable Ext_gettable(string sql, string[] names, object[] values)
        {
            DataSet ds = new DataSet();

            SqlCommand sc = new SqlCommand(sql, new SqlConnection(ext_constr));

            if (values != null)
            {
                for (int i = 0; i < values.Length; i++)
                {
                    sc.Parameters.AddWithValue(names[i], values[i]);
                }
            }

            sc.Connection.Open();

            sda = new SqlDataAdapter(sc);

            sda.Fill(ds);

            return ds.Tables[0];
        }

        public static DataTable ExtGetTable(string sql,string[] cnames)
        {
            DataTable dt = new DataTable();

            string[][] datas = null;

            SaveLogs(sql, cnames);

            OleDbCommand odc = new OleDbCommand(sql, new OleDbConnection(constr));

            odc.Connection.Open();

            rd = odc.ExecuteReader();

            try
            {
                if (rd.HasRows)//데이터 테이블의 크기가 0보다 크다면
                {
                    int dt_cols_count = rd.FieldCount;

                    int k = 0;
                    //ArrayList temparr = new ArrayList();
                    for (int i = 0; i < cnames.Length; i++)
                    {
                        dt.Columns.Add(cnames[i]);
                    }

                    ArrayList temparr = new ArrayList();
                    while (rd.Read())
                    {
                        for (int j = 0; j < dt_cols_count; j++)
                        {
                            temparr.Add(Convert.ToString(rd[j]));//데이터를 생성한 배열에 저장
                        }
                        k++;
                    }

                    for (int i = 0; i < temparr.Count / dt_cols_count; i++)
                    {
                        datas[i] = new string[dt_cols_count];//해당 행만큼 세부 1차원 배열 생성
                        for (int j = 0; j < dt_cols_count; j++)
                        {
                            datas[i][j] = (string)temparr[(i * dt_cols_count) + j];
                        }
                    }

                    for (int i = 0; i < dt_cols_count; i++)
                    {
                        dt.Rows.Add(datas[i]);
                    }
                }
                else
                {
                    dt = null;//0보다 작다면 null값 설정
                }
            }
            catch (Exception ex)
            {
                Save_Error_Logs(ex.Message);
            }
            finally
            {
                if (odc.Connection.State == ConnectionState.Open)
                {
                    odc.Connection.Close();
                }
                odc.Dispose();
            }

            return dt;
        }

        public static string[][] GetDatas(string sql, string[] names, object[] values)
        {
            string[][] datas = null;

            SaveLogs(sql, values);

            OleDbCommand odc = new OleDbCommand(sql, new OleDbConnection(constr));

            if (values != null)
            {
                for (int i = 0; i < values.Length; i++)
                {
                    odc.Parameters.AddWithValue(names[i], values[i]);
                }
            }

            odc.Connection.Open();

            rd = odc.ExecuteReader();

            try
            {
                if (rd.HasRows)//데이터 테이블의 크기가 0보다 크다면
                {
                    int dt_cols_count = rd.FieldCount;

                    int k = 0;
                    ArrayList temparr = new ArrayList();
                    while (rd.Read())
                    {
                        for (int j = 0; j < dt_cols_count; j++)
                        {
                            temparr.Add(Convert.ToString(rd[j]));//데이터를 생성한 배열에 저장
                        }
                        k++;
                    }

                    datas = new string[temparr.Count / dt_cols_count][];//행만큼의 2차원 배열 생성
                    for (int i = 0; i < temparr.Count / dt_cols_count; i++)
                    {
                        datas[i] = new string[dt_cols_count];//해당 행만큼 세부 1차원 배열 생성
                        for (int j = 0; j < dt_cols_count; j++)
                        {
                            datas[i][j] = (string)temparr[(i * dt_cols_count) + j];
                        }
                    }
                }
                else
                {
                    datas = null;//0보다 작다면 null값 설정
                }
            }
            catch (Exception ex)
            {
                Save_Error_Logs(ex.Message);
            }
            finally
            {
                if (odc.Connection.State == ConnectionState.Open)
                {
                    odc.Connection.Close();
                }
                //if(odc != null) odc.Dispose();
            }

            return datas;
        }

        public static object[][] Get_Inner_Datas(string sql, string[] names, object[] values)
        {
            object[][] datas = null;

            SaveLogs(sql, values);

            OleDbCommand odc = new OleDbCommand(sql, new OleDbConnection(constr));

            if (values != null)
            {
                for (int i = 0; i < values.Length; i++)
                {
                    odc.Parameters.AddWithValue(names[i], values[i]);
                }
            }

            odc.Connection.Open();

            rd = odc.ExecuteReader();

            try
            {
                if (rd.HasRows)//데이터 테이블의 크기가 0보다 크다면
                {
                    int dt_cols_count = rd.FieldCount;

                    int k = 0;
                    ArrayList temparr = new ArrayList();
                    while (rd.Read())
                    {
                        for (int j = 0; j < dt_cols_count; j++)
                        {
                            temparr.Add(rd[j]);//데이터를 생성한 배열에 저장
                        }
                        k++;
                    }

                    datas = new string[temparr.Count / dt_cols_count][];//행만큼의 2차원 배열 생성
                    for (int i = 0; i < temparr.Count / dt_cols_count; i++)
                    {
                        datas[i] = new string[dt_cols_count];//해당 행만큼 세부 1차원 배열 생성
                        for (int j = 0; j < dt_cols_count; j++)
                        {
                            datas[i][j] = temparr[(i * dt_cols_count) + j];
                        }
                    }
                }
                else
                {
                    datas = null;//0보다 작다면 null값 설정
                }
            }
            catch (Exception ex)
            {
                Save_Error_Logs(ex.Message);
            }
            finally
            {
                if (odc.Connection.State == ConnectionState.Open)
                {
                    odc.Connection.Close();
                }
                //if(odc != null) odc.Dispose();
            }

            return datas;
        }

        public static string[][] Ext_GetDatas(string sql, string[] names, object[] values)
        {
            string[][] datas = null;

            Ext_SaveLogs(sql, values);

            //OleDbCommand odc = new OleDbCommand(sql, new OleDbConnection(ext_constr));
            SqlCommand sc = new SqlCommand(sql, new SqlConnection(ext_constr));

            if (values != null)
            {
                for (int i = 0; i < values.Length; i++)
                {
                    sc.Parameters.AddWithValue(names[i], values[i]);
                }
            }

            sc.Connection.Open();

            sdr = sc.ExecuteReader();

            try
            {
                if (sdr.HasRows)//데이터 테이블의 크기가 0보다 크다면
                {
                    int dt_cols_count = sdr.FieldCount;

                    int k = 0;
                    ArrayList temparr = new ArrayList();
                    while (sdr.Read())
                    {
                        for (int j = 0; j < dt_cols_count; j++)
                        {
                            temparr.Add(sdr[j]);//데이터를 생성한 배열에 저장
                        }
                        k++;
                    }

                    datas = new string[temparr.Count / dt_cols_count][];//행만큼의 2차원 배열 생성
                    for (int i = 0; i < temparr.Count / dt_cols_count; i++)
                    {
                        datas[i] = new string[dt_cols_count];//해당 행만큼 세부 1차원 배열 생성
                        for (int j = 0; j < dt_cols_count; j++)
                        {
                            datas[i][j] = temparr[(i * dt_cols_count) + j].ToString();
                        }
                    }
                }
                else
                {
                    datas = null;//0보다 작다면 null값 설정
                }
            }
            catch (Exception ex)
            {
                Ext_Save_Error_Logs(ex.Message);
            }
            finally
            {
                if (sc.Connection.State == ConnectionState.Open)
                {
                    sc.Connection.Close();
                }
                //if(odc != null) odc.Dispose();
            }

            return datas;
        }

        public static int ExcuteQuery(string sql, string[] names, object[] values)
        {
            int state = 0;

            SaveLogs(sql, values);

            OleDbCommand odc = new OleDbCommand(sql, new OleDbConnection(constr));

            if (values != null)
            {
                for (int i = 0; i < values.Length; i++)
                {
                    odc.Parameters.AddWithValue(names[i], values[i]);
                }
            }

            try
            {
                odc.Connection.Open();

                state = odc.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                Save_Error_Logs(ex.Message);
            }
            finally
            {
                if (odc.Connection.State == ConnectionState.Open)
                {
                    odc.Connection.Close();
                }
                odc.Dispose();
            }

            return state;
        }

        public static int Ext_ExcuteQuery(string sql, string[] names,object[] values)
        {
            int state = 0;

            Ext_SaveLogs(sql, values);

            SqlCommand idc = new SqlCommand(sql, new SqlConnection(ext_constr));

            if (values != null)
            {
                for (int i = 0; i < values.Length; i++)
                {
                    idc.Parameters.AddWithValue(names[i], values[i]);
                }
            }

            try
            {
                idc.Connection.Open();

                state = idc.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                Ext_Save_Error_Logs(ex.Message);
            }
            finally
            {
                if (idc.Connection.State == ConnectionState.Open)
                {
                    idc.Connection.Close();
                }
                idc.Dispose();
            }

            return state;
        }

        public static bool SaveLogs(string sql, object[] values)
        {
            bool state = false;

            try
            {
                using (StreamWriter sw = new StreamWriter("./querylogs.txt", true))
                {
                    sw.WriteLine("---------------------------------");
                    sw.WriteLine(DateTime.Now.ToString());
                    sw.WriteLine(sql);
                    if (values != null)
                    {
                        foreach (object i in values)
                        {
                            sw.Write(i.ToString() + ", ");
                        }
                        sw.WriteLine();
                    }
                    sw.WriteLine("---------------------------------");
                }
                state = true;
            }
            catch (Exception ex)
            {
                state = false;
                Save_Error_Logs(ex.Message);
            }

            return state;
        }

        public static bool Ext_SaveLogs(string sql, object[] values)
        {
            bool state = false;

            try
            {
                using (StreamWriter sw = new StreamWriter("./Ext_querylogs.txt", true))
                {
                    sw.WriteLine("---------------------------------");
                    sw.WriteLine(DateTime.Now.ToString());
                    sw.WriteLine(sql);
                    if (values != null)
                    {
                        foreach (object i in values)
                        {
                            sw.Write(i.ToString() + ", ");
                        }
                        sw.WriteLine();
                    }
                    sw.WriteLine("---------------------------------");
                }
                state = true;
            }
            catch (Exception ex)
            {
                state = false;
                Save_Error_Logs(ex.Message);
            }

            return state;
        }

        public static int ExcuteQuery(string sql)
        {
            int state = 0;

            OleDbCommand odc = new OleDbCommand(sql, new OleDbConnection(constr));

            try
            {
                odc.Connection.Open();

                state = odc.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                Save_Error_Logs(ex.Message);
            }
            finally
            {
                if (odc.Connection.State == ConnectionState.Open)
                {
                    odc.Connection.Close();
                }
                odc.Dispose();
            }

            return state;
        }

        public static int Updating_External_Servers(string logfile)
        {
            int state = 0;

            return state;
        }

        public static bool Save_Error_Logs(string errormesage)
        {
            bool state = false;

            try
            {
                using (StreamWriter sw = new StreamWriter("./errorlogs.txt", true))
                {
                    sw.WriteLine("---------------------------------");
                    sw.WriteLine(DateTime.Now.ToString());
                    sw.WriteLine(errormesage);
                    sw.WriteLine("---------------------------------");
                }
                state = true;
            }
            catch (Exception)
            {
                state = false;
            }

            return state;
        }

        public static bool Ext_Save_Error_Logs(string errormesage)
        {
            bool state = false;

            try
            {
                using (StreamWriter sw = new StreamWriter("./Ext_errorlogs.txt", true))
                {
                    sw.WriteLine("---------------------------------");
                    sw.WriteLine(DateTime.Now.ToString());
                    sw.WriteLine(errormesage);
                    sw.WriteLine("---------------------------------");
                }
                state = true;
            }
            catch (Exception)
            {
                state = false;
            }

            return state;
        }
    }
}



by Tomoya 2009.07.20 11:49

아래 개선형 DB 긁기 (C# 2.0)
처리속도도 빠르고 역시 모든 SQL형태에 대응 할수 있다.
컨넥션 얻어 오는 것은 아래 글 참조

using System.IO;
using System.Data.Sql;
using System.Data;
using System.Data.OracleClient;
using Oracle.DataAccess;

----------------------------------
OracleCommand cmd = new OracleCommand(sql, DbConn.GetConn());

            OracleDataReader rd;

            Find = null;//길 찾기 배열 초기화

            cmd.Parameters.AddWithValue(":SID", startbstop);
            cmd.Parameters.AddWithValue(":EID", endbstop);

            cmd.Connection.Open();

            rd = cmd.ExecuteReader();
            Find = GetOraDatas(rd);
--------------------------------------------------

//오라클 데이터 받아오기
        public static string[][] GetOraDatas(OracleDataReader rd)
        {
            string[][] datas = null;

            try
            {
                if (rd.HasRows)//데이터 테이블의 크기가 0보다 크다면
                {
                    int dt_cols_count = rd.FieldCount;

                    int k = 0;
                    ArrayList temparr = new ArrayList();
                    while(rd.Read())
                    {
                        for (int j = 0; j < dt_cols_count; j++)
                        {
                            temparr.Add(Convert.ToString(rd[j]));//데이터를 생성한 배열에 저장
                        }
                        k++;
                    }

                    bisdatas = new string[temparr.Count/dt_cols_count][];//행만큼의 2차원 배열 생성
                    for (int i = 0; i < temparr.Count / dt_cols_count; i++)
                    {
                        bisdatas[i] = new string[dt_cols_count];//해당 행만큼 세부 1차원 배열 생성
                        for (int j = 0; j < dt_cols_count; j++)
                        {
                            datas[i][j] = (string)temparr[(i * dt_cols_count) + j];
                        }
                    }
                }
                else
                {
                    bisdatas = null;//0보다 작다면 null값 설정
                }
            }
            catch (Exception ex)
            {
                using (StreamWriter sw = new StreamWriter("./sqlerror.txt"))
                {
                    //string message = "can not read file";
                    sw.WriteLine(ex.Message);//오류 발생시 sql에러로 저장
                }
            }
            finally
            {
               
            }

            return datas;//해당 sql문의 쿼리 결과를 2차원 문자열 배열로 전송
        }

by Tomoya 2009.04.13 17:56

내가 DB 쿼리문 던질 때 쓰는 방법..

장점 : C# OleDB를 이용해 모든 SQL 쿼리문에 대응한다.
쉽게 말해 쿼리문만 작성해서 string [][] datas = DataReader.GetData(sql);식으로 받아오면
어떤 쿼리문이든 결과값을 문자열 배열형태로 변화해서 가져올 수있다.
코드량을 상당히 줄일수 있으며 정형화 시켜 한 번 받아 오는게 정상적으로 받아 왔다면 다른 쿼리문에도 쉽게 적용 가능하다.

단점 : "select a from b where c = ?" c :값 형식으로 보낼때와 달리 DB부하가 많이 간다.
DB를 자주 긁는 입장이라면 주의 필요하다.(쉽게 이야기하면 DB 쿼리문 파싱이 안된다는 것이다.)

C# 2.0 (VS2005)

DAO - 접속을 관리한다.

using System;
using System.Collections.Generic;
using System.Text;
using System.Data.OleDb;
using System.Data.Odbc;
using System.Data.Sql;
using System.Data;
using System.IO;

    public class Dao
    {
        //연결설정 문자열 설정
        private static string connstr = "Provider=MSDAORA;Data Source=DB adress;Password=패스워드;User ID=아이디";

        //오라클 데이터 어댑터 객체 생성
        private static OleDbDataAdapter da;

        //데이터를 받을 데이터 셋 객체
        private static DataSet ds;

        //데이터를 받을 데이터 테이블 객체
        private static DataTable dt;

        public Dao()//생성시 기본값을 널로 설정
        {
            da = null;
            ds = null;
            dt = null;
        }

        public static void OleConn(string sql)//OLE DB 연결
        {
            try
            {
                da = new OleDbDataAdapter(sql, connstr);//db연결해서 데이터 어댑터를 설정하고
               

                ds = new DataSet();//데이터 셋을 생성하여

                da.Fill(ds, "테이블");//연결한 어댑터를 이용해 데이터 셋을 설정하고

                dt = ds.Tables["테이블"];//데이터 테이블에 데이터셋의 정보를 넣음
            }
            catch (Exception ex)
            {
                //FileInfo fi = new FileInfo("C:\\LOG"); - 웹 일경우 보안 정책 위반 가능성 있으므로
                //if (!fi.Exists) fi.Create();
                using (StreamWriter sw = new StreamWriter("./sqlerror.txt", true))
                {
                    //string message = "can not read file";
                    sw.WriteLine(ex.Message);//dql관련 문제가 생겼다면 파일로 오류메시지 저장
                }
            }
        }

        public static void OleDisConn()//연결 해제
        {
            try
            {
                if (dt != null)
                {
                    dt.Dispose();
                    dt = null;
                }
                if (ds != null)
                {
                    ds.Dispose();
                    ds = null;
                }

                if (da != null)
                {
                    da.Dispose();
                    da = null;
                }
            }
            catch (Exception ex)
            {
                //FileInfo fi = new FileInfo("C:\\LOG");
                //if (!fi.Exists) fi.Create();
                using (StreamWriter sw = new StreamWriter("./sqlerror.txt"))
                {
                    //string message = "can not read file";
                    sw.WriteLine(ex.Message);
                }
            }
        }

        public static DataTable Get_DataTable(string sql) //데이터 테이블 통째로 들고 오고 싶을 때
        {
            OleConn(sql);//연결하고 그 테이블을 반환

            return dt;
        }

        public static int ExecuteQuery(string sql)
        {
            int rows = 0;
            OleDbConnection conn = null;
            OleDbCommand odc = null;
            try
            {
                conn = new OleDbConnection(connstr);
                conn.Open();

                odc = new OleDbCommand(sql, conn);

                rows = odc.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                //FileInfo fi = new FileInfo("C:\\LOG");
                //if (!fi.Exists) fi.Create();
                using (StreamWriter sw = new StreamWriter("./sqlerror.txt", true))
                {
                    //string message = "can not read file";
                    sw.WriteLine(ex.Message);//dql관련 문제가 생겼다면 파일로 오류메시지 저장
                }
            }
            finally
            {
                if (odc != null) odc.Dispose();
                if (conn != null) conn.Close();
            }

            return rows;
        }
    }

using System;
using System.Collections.Generic;
using System.Text;
using System.Data.OleDb;
using System.Data.Odbc;
using System.Data.Sql;
using System.Data;
using System.Data.Common;
using System.IO;


    //DB에 접근해 데이터를 읽을 클래스
    public class DataReader
    {
        //private static Dao dao;//DB 연결자
        private static DataTable dt;//쿼리문에 대한 가상 테이블(뷰)

        //생성자
        public DataReader()
        {
            //dao = new Dao();
        }

        //데이터 양을 알수 없거나 많을 경우
        public static string[][] GetDatas(string sql)
        {
            string[][] datas = null;

            try
            {
                dt = Dao.Get_DataTable(sql);//데이터 테이블을 얻어옴

                int dt_rows_count = dt.Rows.Count;//데이터 테이블의 행 수 얻기
                int dt_cols_count = dt.Columns.Count;//데이터 테이블의 칼럼 수 얻기

                if (dt_rows_count > 0)//데이터 테이블의 크기가 0보다 크다면
                {
                    datas = new string[dt_rows_count][];//행만큼의 2차원 배열 생성
                    for (int i = 0; i < dt_rows_count; i++)
                    {
                        datas[i] = new string[dt_cols_count];//해당 행만큼 세부 1차원 배열 생성
                    }

                    for (int i = 0; i < dt_rows_count; i++)
                    {
                        for (int j = 0; j < dt_cols_count; j++)
                        {
                            datas[i][j] = Convert.ToString(dt.Rows[i][j]);//데이터를 생성한 배열에 저장
                        }
                    }
                }
                else
                {
                    datas = null;//0보다 작다면 null값 설정
                }
            }
            catch (Exception ex)
            {
                using (StreamWriter sw = new StreamWriter("./sqlerror.txt"))
                {
                    //string message = "can not read file";
                    sw.WriteLine(ex.Message);//오류 발생시 sql에러로 저장
                }
            }
            finally
            {
                dt.Dispose();//데이터 테이블 해제
            }

            return datas;//해당 sql문의 쿼리 결과를 2차원 문자열 배열로 전송
        }

        //1행만 받아오는 경우
        public static string[] GetOneDatas(string sql)
        {
            string[] datas = null;

            try
            {
                dt = Dao.Get_DataTable(sql);//데이터 테이블을 받아와서

                int dt_rows_count = dt.Rows.Count;//행수 받아옴
                int dt_cols_count = dt.Columns.Count;//칼럼수 받아옴

                if (dt_rows_count == 1)//행이 1개일때
                {
                    datas = new string[dt_cols_count];//배열 생성

                    for (int j = 0; j < dt_cols_count; j++)
                    {
                        datas[j] = Convert.ToString(dt.Rows[0][j]);//데이터 저장
                    }
                }
                else//1행이 아닐때
                {
                    datas = null;//널값으로 설정
                }
            }
            catch (Exception ex)
            {
                using (StreamWriter sw = new StreamWriter("./sqlerror.txt"))
                {
                    //string message = "can not read file";
                    sw.WriteLine(ex.Message);//에러 메시지 저장
                }
            }
            finally
            {
                dt.Dispose();//데이터 테이블 해제
            }
            return datas;//쿼리 결과 반환
        }

        //1개의 데이터만 받는 경우
        public static string GetData(string sql)
        {
            string datas = null;

            try
            {
                dt = Dao.Get_DataTable(sql);//쿼리 실행

                int dt_rows_count = dt.Rows.Count;//행수 반환
                int dt_cols_count = dt.Columns.Count;//칼럼수 반환

                if (dt_rows_count == 1 && dt_cols_count == 1)//칼럼1 행 1이면
                {
                    datas = Convert.ToString(dt.Rows[0][0]);//데이터를 문자열로 저장
                }
                else
                {
                    datas = null;//아니라면 널값 설정
                }
            }
            catch (Exception ex)
            {
                using (StreamWriter sw = new StreamWriter("./sqlerror.txt"))
                {
                    //string message = "can not read file";
                    sw.WriteLine(ex.Message);
                }
            }
            finally
            {
                dt.Dispose();
            }
            return datas;//결과 반환
        }

    }

p.s Java버전은 다음에 하려 했지만..보는 사람 없는 듯..요청 없으면 그냥 패스..

by Tomoya 2009.03.09 18:05
| 1 |