C# System.Data.OleDb.OleDbConnection.CreateCommand方法代码示例

        public void BuildAxisOrderBitArray()
        {
            if (!File.Exists(EpsgAccessDatabase))
                throw new IgnoreException("Epsg Access Database not found");

            var ba = new BitArray(32768);

            using (var cn = new System.Data.OleDb.OleDbConnection(
                string.Format("Provider=Microsoft.Jet.OLEDB.4.0; Data Source={0};", EpsgAccessDatabase)))
            {
                cn.Open();
                var cmd = cn.CreateCommand();
                cmd.CommandText = Sql;
                using (var dr = cmd.ExecuteReader())
                {
                    if (dr != null)
                    while (dr.Read())
                    {
                        var code = dr.GetInt32(0);
                        if (code > 32767) continue;
                        ba[code] = true;
                    }
                }
            }

            string enc;
            var buffer = new byte[4096];
            ba.CopyTo(buffer, 0);

            #if NET45
            using (var bufferStream = new MemoryStream(buffer))
            {
                using (var compressedStream = new MemoryStream())
                {
                    using (var s = new DeflateStream(compressedStream, CompressionMode.Compress))
                    {
                        bufferStream.CopyTo(s);
                        compressedStream.Flush();
                    }
                    enc = Convert.ToBase64String(compressedStream.ToArray());
                    Console.WriteLine("Compressed");
                    WriteBlocks(enc);
                }
            }
            #endif
            enc = Convert.ToBase64String(buffer);
            Console.WriteLine("\nUncompressed");
            WriteBlocks(enc);

            Console.WriteLine("\nByte array");
            WriteBytes(buffer, 20);
        }

        public void TestCreateEpsgToUom()
        {
            if (!File.Exists(EpsgAccessDatabase))
                throw new IgnoreException("Epsg Access Database not found");

            using (var cn = new System.Data.OleDb.OleDbConnection(
                string.Format("Provider=Microsoft.Jet.OLEDB.4.0; Data Source={0};", EpsgAccessDatabase)))
            {
                cn.Open();
                var cmd = cn.CreateCommand();
                cmd.CommandText = SqlEpsgToUom;
                var ms = new MemoryStream();
                var bw = new BinaryWriter(ms);
                using (var dr = cmd.ExecuteReader())
                {
                    if (dr != null)
                        while (dr.Read())
                        {
                            if ((int)dr[0] > 32768) break;

                            //Console.WriteLine("{0} -> {1}", dr[0], dr[1]);
                            var uom = Convert.ToInt16(dr[1]);
                            if (uom == 9001) continue;
                            if (Convert.ToInt16(dr[2]) == 9102)
                                uom = 9102;

                            var epsg = Convert.ToUInt16(dr[0]);
                            bw.Write(epsg);
                            bw.Write(uom);
                        }
                }

                ms.Seek(0, SeekOrigin.Begin);
                var br = new BinaryReader(ms);
                var count = 0;
                while (ms.Position < ms.Length)
                {
                    var byteValue = br.ReadByte();
                    Console.Write("{0}, ", byteValue);
                    count++;
                    if (count % 16 == 0) Console.Write("\n");

                }
            }
        }

        public void TestAxisOrder()
        {
            if (!File.Exists(EpsgAccessDatabase))
                throw new IgnoreException("Epsg Access Database not found");

            var unusual = new HashSet<int>();

            using (var cn = new System.Data.OleDb.OleDbConnection(
                string.Format("Provider=Microsoft.Jet.OLEDB.4.0; Data Source={0};", EpsgAccessDatabase)))
            {
                cn.Open();
                var cmd = cn.CreateCommand();
                cmd.CommandText = Sql;
                using (var dr = cmd.ExecuteReader())
                {
                    if (dr != null)
                        while (dr.Read())
                        {
                            var code = dr.GetInt32(0);
                            if (code > 32767) continue;
                            unusual.Add(code);
                        }
                }
            }
            var crsAOR = new CrsAxisOrderRegistry();

            /*
            foreach (var code in unusual)
            {
                CrsIdentifier crs;
                if (CrsIdentifier.TryParse("urn:ogc:def:crs:EPSG::" + code, out crs))
                    Assert.AreEqual(1, crsAOR[crs][0]);
            }*/

            for (var code = 1; code < 32768; code++)
            {
                CrsIdentifier crs;
                if (CrsIdentifier.TryParse("urn:ogc:def:crs:EPSG::" + code, out crs))
                {
                    var expected = unusual.Contains(code) ? 1 : 0;
                    Assert.AreEqual(expected, crsAOR[crs][0]);
                }
            }
        }

 private static void Spike_OleDbConnection_With_ConnectionString(string[] args)
 {
     var cs = System.Configuration.ConfigurationManager.ConnectionStrings["NespeDataContext"];
     using (var cnn = new System.Data.OleDb.OleDbConnection(cs.ConnectionString))
     {
         using (var cmd = cnn.CreateCommand())
         {
             cmd.CommandText = "select 1+1";
             cnn.Open();
             var v = cmd.ExecuteScalar();
             Console.WriteLine(v);
         }
     }
 }

        private string SelKontaktName(int kontakt_id)
        {
            if (kontakt_id == 0)
            {
                return "";
            }
            else
            {
                string verbindungsstring = @"Provider=Microsoft.ACE.OLEDB.12.0; Data Source=C:\Temp\Terminverwaltung.accdb";

                System.Data.OleDb.OleDbConnection dBVerbindung = null;
                System.Data.OleDb.OleDbCommand befehl = null;
                System.Data.OleDb.OleDbDataReader datenleser = null;
                bool offen = false;

                try
                {
                    dBVerbindung = new System.Data.OleDb.OleDbConnection(verbindungsstring);
                    dBVerbindung.Open();
                    offen = true;

                    befehl = dBVerbindung.CreateCommand();
                    befehl.CommandText = "select Name & ', ' & Vorname as Kname \n"
                        + "from Kontakte \n"
                        + "where Kontakt_ID = " + kontakt_id;

                    datenleser = befehl.ExecuteReader();

                    // Liefert folgende Spalten zurück:
                    // 0 - Kontaktname
                    while (datenleser.Read())
                    {
                        if (datenleser.GetValue(0) == null)
                            return "null";
                        else
                        {
                            MessageBox.Show(datenleser.GetString(0));
                            return datenleser.GetString(0).ToString();
                        }

                    }
                }
                catch (Exception ausnahme)
                {
                    MessageBox.Show("Datenbankfehler: " + ausnahme.Message);
                    return "";
                }
                finally
                {
                    if (offen == true)
                    {
                        dBVerbindung.Close();
                    }
                }
                MessageBox.Show("4");
                return "";
            }
        }

        // Aufruf mit übergebener Termin-ID --> Vorhandenen Termin bearbeiten
        public Terminbearbeitung(int termID)
        {
            InitializeComponent();

            if(termID == 0)
            {
                MessageBox.Show("Fehlerhafte Termin-ID wurde übergeben!");
            }
            else
            {
                terminID = termID;
                // Kontaktliste füllen
                FillListKontakte();
                string verbindungsstring = @"Provider=Microsoft.ACE.OLEDB.12.0; Data Source=C:\Temp\Terminverwaltung.accdb";

                System.Data.OleDb.OleDbConnection dBVerbindung = null;
                System.Data.OleDb.OleDbCommand befehl = null;
                System.Data.OleDb.OleDbDataReader datenleser = null;
                bool offen = false;

                try
                {
                    dBVerbindung = new System.Data.OleDb.OleDbConnection(verbindungsstring);
                    dBVerbindung.Open();
                    offen = true;

                    befehl = dBVerbindung.CreateCommand();
                    befehl.CommandText = "select Termin_ID, Titel, Datum, Uhrzeit, Beschreibung, Kontakt \n"
                        + "from Termine \n"
                        + "where Termin_ID = " + terminID;

                    datenleser = befehl.ExecuteReader();

                    // Liefert folgende Spalten zurück:
                    // 0 - Termin_ID; 1 - Titel; 2 - Datum; 3 - Uhrzeit; 4 - Beschreibung
                    // 5 - Kontakt_ID
                    while (datenleser.Read())
                    {
                        textBoxTitel.Text = datenleser.GetString(1);
                        textBoxDatum.Text = datenleser.GetDateTime(2).ToString("dd.MM.yyyy");
                        textBoxUhrzeit.Text = datenleser.GetDateTime(3).ToString("HH:mm");
                        textBoxBeschreibung.Text = datenleser.GetString(4);

                        if (datenleser.GetValue(5).ToString() == "")
                        // Auf letztes Item = kein Kontakt stellen
                        {
                            listBoxKontakt.SelectedIndex = listBoxKontakt.Items.Count - 1;
                        }
                        else
                        {
                            MessageBox.Show(datenleser.GetInt32(5).ToString());
                            listBoxKontakt.SelectedValue = datenleser.GetInt32(5);
                        }
                    }
                }
                catch (Exception ausnahme)
                {
                    MessageBox.Show("Datenbankfehler: " + ausnahme.Message);
                }
                finally
                {
                    if (offen == true)
                    {
                        dBVerbindung.Close();
                    }
                }
            }
        }

        // List-Item füllen
        private void FillListKontakte()
        {
            // Füllen der Listbox
            string verbindungsstring = @"Provider=Microsoft.ACE.OLEDB.12.0; Data Source=C:\Temp\Terminverwaltung.accdb";

            System.Data.OleDb.OleDbConnection dBVerbindung = null;
            System.Data.OleDb.OleDbCommand befehl = null;
            System.Data.OleDb.OleDbDataReader datenleser = null;
            bool offen = false;

            try
            {
                dBVerbindung = new System.Data.OleDb.OleDbConnection(verbindungsstring);
                dBVerbindung.Open();
                offen = true;

                befehl = dBVerbindung.CreateCommand();
                befehl.CommandText = "select ko.Kontakt_ID, ko.Name & ', ' & ko.Vorname as KName \n"
                    + "from Kontakte ko \n"
                    + "order by ko.Name, ko.Vorname";

                datenleser = befehl.ExecuteReader();

                DataTable dt = new DataTable();

                dt.Load(datenleser);

                dt.Rows.Add();

                listBoxKontakt.DataSource = dt;

                listBoxKontakt.DisplayMember = "KName";
                listBoxKontakt.ValueMember = "Kontakt_ID";
            }
            catch (Exception ausnahme)
            {
                MessageBox.Show("Datenbankfehler: " + ausnahme.Message);
            }
            finally
            {
                if (offen == true) dBVerbindung.Close();
            }
        }

        private void buttonSpeichern_Click(object sender, EventArgs e)
        {
            // Über die Termin-ID kann geprüft werden, ob ein bestehender Datensatz
            // bearbeitet werden soll oder ein neuer eingefügt werden soll
            if (terminID == 0)
            {
                if (textBoxTitel.Text != null && textBoxDatum != null && textBoxUhrzeit != null)
                {
                    // Neuen Termin anlegen
                    string verbindungsstring = @"Provider=Microsoft.ACE.OLEDB.12.0; Data Source=C:\Temp\Terminverwaltung.accdb";

                    System.Data.OleDb.OleDbConnection dBVerbindung = null;
                    System.Data.OleDb.OleDbCommand befehl = null;
                    bool offen = false;

                    try
                    {
                        dBVerbindung = new System.Data.OleDb.OleDbConnection(verbindungsstring);
                        dBVerbindung.Open();
                        offen = true;

                        // Je nach Kontaktauswahl "null" oder den Wert beim Insert angeben
                        string kontakt;

                        if (listBoxKontakt.SelectedValue.ToString() == "")
                            kontakt = "null";
                        else
                            kontakt = listBoxKontakt.SelectedValue.ToString();

                        befehl = dBVerbindung.CreateCommand();
                        befehl.CommandText = "insert into Termine (Titel, Datum, Uhrzeit, Beschreibung, Kontakt) values ('"
                            + textBoxTitel.Text + "', '"
                            + textBoxDatum.Text + "', '"
                            + textBoxUhrzeit.Text + "', '"
                            + textBoxBeschreibung.Text + "', "
                            + kontakt + ")";

                        int anzahl = befehl.ExecuteNonQuery();
                    }
                    catch (Exception ausnahme)
                    {
                        MessageBox.Show("Datenbankfehler: " + ausnahme.Message);
                    }
                    finally
                    {
                        if (offen == true) dBVerbindung.Close();
                    }
                }
                else
                {
                    MessageBox.Show("Bitte geben Sie mindestens einen Titel, das Datum und die Uhrzeit an!");
                }
            }
            else
            {
                // Bestehenden Termin updaten
                if (textBoxTitel.Text != null && textBoxDatum != null && textBoxUhrzeit != null)
                {
                    // Neuen Termin anlegen
                    string verbindungsstring = @"Provider=Microsoft.ACE.OLEDB.12.0; Data Source=C:\Temp\Terminverwaltung.accdb";

                    System.Data.OleDb.OleDbConnection dBVerbindung = null;
                    System.Data.OleDb.OleDbCommand befehl = null;
                    bool offen = false;

                    try
                    {
                        dBVerbindung = new System.Data.OleDb.OleDbConnection(verbindungsstring);
                        dBVerbindung.Open();
                        offen = true;

                        // Je nach Kontaktauswahl "null" oder den Wert beim Insert angeben
                        string kontakt;
                        if (listBoxKontakt.SelectedValue.ToString() == "")
                            kontakt = "null";
                        else
                            kontakt = listBoxKontakt.SelectedValue.ToString();

                        befehl = dBVerbindung.CreateCommand();
                        befehl.CommandText = "update Termine \n"
                            + "set Titel = '" + textBoxTitel.Text + "', \n"
                            + "Datum = '" + textBoxDatum.Text + "', \n"
                            + "Uhrzeit = '" + textBoxUhrzeit.Text + "', \n"
                            + "Beschreibung = '" + textBoxBeschreibung.Text + "', \n"
                            + "Kontakt = " + kontakt + " \n"
                            + "where Termin_ID = " + terminID;

                        int anzahl = befehl.ExecuteNonQuery();
                    }
                    catch (Exception ausnahme)
                    {
                        MessageBox.Show("Datenbankfehler: " + ausnahme.Message);
                    }
                    finally
                    {
                        if (offen == true) dBVerbindung.Close();
                    }
                }
                else
                {
//.........这里部分代码省略.........

        public void TermineAbfragen()
        {
            string verbindungsstring = @"Provider=Microsoft.ACE.OLEDB.12.0; Data Source=C:\Temp\Terminverwaltung.accdb";

            System.Data.OleDb.OleDbConnection dBVerbindung = null;
            System.Data.OleDb.OleDbCommand befehl = null;
            System.Data.OleDb.OleDbDataReader datenleser = null;
            bool offen = false;

            try
            {
                dBVerbindung = new System.Data.OleDb.OleDbConnection(verbindungsstring);
                dBVerbindung.Open();
                offen = true;

                befehl = dBVerbindung.CreateCommand();
                befehl.CommandText = "select * from Termine";

                datenleser = befehl.ExecuteReader();

                // Liefert folgende Spalten zurück:
                // 0 - Termin_ID; 1 - Titel; 2 - Datum; 3 - Uhrzeit; 4 - Beschreibung
                // 5 - Kontakt
                while (datenleser.Read())
                {
                    // Feststellen, ob der Termin in der aktuellen Auswahl angezeigt
                    // werden muss
                    if (datenleser.GetDateTime(2) >= StartOfWeek(WeekPicker.Value, DayOfWeek.Monday) &&
                        datenleser.GetDateTime(2) <= EndOfWeek(WeekPicker.Value, DayOfWeek.Sunday))
                    {
                        // Reihe = Stundenzahl - 1 (weil Index bei 0 beginnt) - 5 (weil die ersten 5
                        //    Stunden des Tages nicht angezeiggt werden
                        int row = Int32.Parse(datenleser.GetDateTime(3).ToString("HH")) - 6;
                        int col = (int)datenleser.GetDateTime(2).DayOfWeek;
                        TerminGridView.Rows[row].Cells[col].Value = datenleser.GetString(1);

                        // Im Hintergrund wird ein zweidimensionales Int-Array mit aufgebaut,
                        //   um die IDs der Termine passend zur Zeile und Spalte der TerminGridView
                        //   zu verwalten
                        termIDs[row, col] = datenleser.GetInt32(0);
                    }
                }
            }
            catch (Exception ausnahme)
            {
                MessageBox.Show("Datenbankfehler: " + ausnahme.Message);
            }
            finally
            {
                if (offen == true) dBVerbindung.Close();
            }
        }

        // Selektiert die Terminbeschreibung zu einer übergebenen
        // Termin-ID
        private string SelectTermBeschreibung(int termID)
        {
            string verbindungsstring = @"Provider=Microsoft.ACE.OLEDB.12.0; Data Source=C:\Temp\Terminverwaltung.accdb";

            System.Data.OleDb.OleDbConnection dBVerbindung = null;
            System.Data.OleDb.OleDbCommand befehl = null;
            System.Data.OleDb.OleDbDataReader datenleser = null;
            bool offen = false;

            try
            {
                dBVerbindung = new System.Data.OleDb.OleDbConnection(verbindungsstring);
                dBVerbindung.Open();
                offen = true;

                befehl = dBVerbindung.CreateCommand();
                befehl.CommandText = "select Beschreibung from Termine where Termin_ID = " + termID;

                datenleser = befehl.ExecuteReader();

                // Liefert folgende Spalten zurück:
                // 0 - Beschreibung
                while (datenleser.Read())
                {
                    return datenleser.GetString(0);
                }
            }
            catch (Exception ausnahme)
            {
                MessageBox.Show("Datenbankfehler: " + ausnahme.Message);
            }
            finally
            {
                if (offen == true) dBVerbindung.Close();
            }
            return "";
        }

        static void Main(string[] args)
        {
            // set up variables with default values
            string dbName = ConfigurationManager.AppSettings["DefaultDbName"];
            string folderName = ConfigurationManager.AppSettings["DefaultFolderName"];

            // set up capitalized word list
            List<string> capitalizedWords = new List<string>();
            foreach (var word in ConfigurationManager.AppSettings["CapitalizedWordList"].Split(','))
                capitalizedWords.Add(word.Trim());

            // prepare for songs
            List<Song> songs = new List<Song>();

            // get argument list
            if (args.Length > 0)
                dbName = args[0];
            if (args.Length > 1)
                folderName = args[1];

            // ensure database exists
            if (!File.Exists(dbName))
                throw new FileNotFoundException("Could not find database file!", dbName);

            // ensure folder exists (or create it)
            if (!Directory.Exists(folderName))
                Directory.CreateDirectory(folderName);

            // build the connection string
            DbConnectionStringBuilder builder = new DbConnectionStringBuilder();
            builder.ConnectionString = ConfigurationManager.ConnectionStrings["Access"].ConnectionString;
            builder.Add("Data Source", dbName);

            // get a new connection
            using (IDbConnection conn = new System.Data.OleDb.OleDbConnection(builder.ConnectionString))
            {
                conn.Open();

                IDbCommand cmd = conn.CreateCommand();
                cmd.CommandText = "SELECT SongTitle, Song, Chorus2, Chorus3, Chorus4, Verse1, Verse2, Verse3, Verse4 FROM Songs";

                using(IDataReader reader = cmd.ExecuteReader(CommandBehavior.CloseConnection))
                {
                    Song currSong;
                    while (reader.Read())
                    {
                        currSong = new Song(
                            System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(Regex.Replace(reader.GetString(0).ToLower(), @"\s+", " "))
                        );

                        for (int i = 1; i < reader.FieldCount; i++)
                            if ((!reader.IsDBNull(i)) && (!string.IsNullOrWhiteSpace(reader.GetString(i))))
                                currSong.Parts.Add(x[reader.GetName(i)], Normalize(reader.GetString(i), capitalizedWords));

                        songs.Add(currSong);
                    }
                }
            }

            foreach (var song in songs)
                song.Serialize(File.Open(Path.Combine(folderName, MakeValidFileName(song.Name + ".txt")), FileMode.Truncate, FileAccess.Write, FileShare.Write));
        }

        public void TestCreateRegistryEntries()
        {
            if (!File.Exists(EpsgAccessDatabase))
                throw new IgnoreException("Epsg Access Database not found");

            using (var cn = new System.Data.OleDb.OleDbConnection(
                string.Format("Provider=Microsoft.Jet.OLEDB.4.0; Data Source={0};", EpsgAccessDatabase)))
            {
                cn.Open();
                var cmd = cn.CreateCommand();
                cmd.CommandText = SqlLength;
                using (var dr = cmd.ExecuteReader())
                {
                    if (dr != null)
                        while (dr.Read())
                        {
                            Console.WriteLine("_registry.Add({0}, new UnitOfMeasure(\"{1}\", {2}d/{3}d));",
                                dr.GetInt32(0), dr.GetString(1),
                                dr.GetDouble(2).ToString(NumberFormatInfo.InvariantInfo),
                                dr.GetDouble(3).ToString(NumberFormatInfo.InvariantInfo));
                        }
                }
                cmd.CommandText = SqlAngle;
                using (var dr = cmd.ExecuteReader())
                {
                    if (dr != null)
                        while (dr.Read())
                        {
                            Console.WriteLine(
                                "_registry.Add({0}, new UnitOfMeasure(\"{1}\", 0.5 * EarthCircumference * {2}d/{3}d));",
                                dr.GetInt32(0), dr.GetString(1),
                                dr.GetDouble(2).ToString(NumberFormatInfo.InvariantInfo),
                                dr.GetDouble(3).ToString(NumberFormatInfo.InvariantInfo));
                        }
                }
            }
        }

        public void TestEpsgCodeUom()
        {
            if (!File.Exists(EpsgAccessDatabase))
                throw new IgnoreException("Epsg Access Database not found");

            using (var cn = new System.Data.OleDb.OleDbConnection(
                string.Format("Provider=Microsoft.Jet.OLEDB.4.0; Data Source={0};", EpsgAccessDatabase)))
            {
                cn.Open();
                var cmd = cn.CreateCommand();
                cmd.CommandText = SqlEpsgToUom;
                var uomr = new CrsUnitOfMeasureRegistry();
                using (var dr = cmd.ExecuteReader())
                {
                    if (dr != null)
                        while (dr.Read())
                        {
                            if ((int)dr[0] > 32768) break;

                            CrsIdentifier crs;
                            if (CrsIdentifier.TryParse(string.Format("urn:ogc:def:crs:EPSG::{0}", dr.GetInt32(0)), out crs))
                            {
                                var uom = new UnitOfMeasure();
                                Assert.DoesNotThrow(() => uom = uomr[crs], "Getting unit of measure failed for {0}", crs);

                                var uomCode = dr.GetInt32(1);
                                if (uomCode == 9001 || uomCode == 1024)
                                    Assert.AreEqual(1d, uom.ToMeter, "Unit of measure ToMeter is not 1d: {0}", crs);
                                else
                                    Assert.AreNotEqual(1d, uom.ToMeter, "Unit of measure ToMeter should not be 1d: {0}", crs);
                            }
                        }
                }
            }
        }