|
The Directory of a Database |
|
One of the biggest differences between a database and a
regular application is that, traditionally, although not always, all of the
files of a database are located in the same directory. The directory can be
local and accessed only by one computer. The directory can be located in one
computer and accessed by various users on different computers or a workgroup.
The directory can be located on a server that no user directly uses but that
directory's files can be accessed from one or more computers.
Another particularity of a database is that usually you, the
database developer, create and manage the directory or directories used by the
application.
Another difference of a database as compared to a regular
application is that, while using the database, users do not create files. This
means that there is no actual file processing on the part of the users. For
example, the user does not even open the database in the traditional sense. You,
the database developer, provides a means of accessing the database. Then, the
user adds, edits, or deletes values.
Based on the above discussion of directories, when creating
a file-based application, one the first actions you should perform consists of
setting up the directory where the file(s) of your application would be located.
If you already know (and you should know) where and how the application would be
accessed, you can manually create a folder using Windows Explorer, My Computer,
or any appropriate utility. Otherwise, you can still programmatically create the
directory.
The .NET
Framework supports the creation and management of directories through various
classes. The main class used to deal with directories is called Directory.
Besides the Directory class, the .NET Framework provides
support for folders through a class named DirectoryInfo. To use it, declare a variable of type DirectoryInfo using its constructor
to initialize it.
To actually create a directory using the static Directory
class, you can call its CreateDirectory() method
that is overloaded with two versions. Here is an example:
Header File: Exercise.h
#pragma once
#using <System.dll>
#using <System.Drawing.dll>
#using <System.Windows.Forms.dll>
using namespace System;
using namespace System::IO;
using namespace System::Drawing;
using namespace System::Windows::Forms;
public ref class CExercise : public Form
{
public:
CExercise(void);
private:
void InitializeComponents();
};
Source File: Exercise.cpp
#include <windows.h>
#include "Exercise.h"
CExercise::CExercise(void)
{
InitializeComponents();
}
void CExercise::InitializeComponents()
{
Text = L"File-Based Application";
StartPosition = FormStartPosition::CenterScreen;
Directory::CreateDirectory("D:\\Bethesda Car Rental");
}
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow)
{
Application::Run(gcnew CExercise());
return 0;
}
To create a folder using the DirectoryInfo
class, call its Create()
method that comes in two versions. Here is an example:
#include <windows.h>
#include "Exercise.h"
CExercise::CExercise(void)
{
InitializeComponents();
}
void CExercise::InitializeComponents()
{
Text = L"File-Based Application";
StartPosition = FormStartPosition::CenterScreen;
DirectoryInfo ^ dirInfo = gcnew DirectoryInfo(L"D:\\Bethesda Car Rental");
dirInfo->Create();
}
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow)
{
Application::Run(gcnew CExercise());
return 0;
}
When you call either the Directory::CreateDirectory()
method or the DirectoryInfo::Create()
method, if the directory does not exist, it would be created. If the directory
exists already, nothing would happen. This means that the compiler would not
attempt to create a directory if there is already one in the indicated location
and you can safely call any of these methods without the risk of deleting its existing
files, if any.
Before performing any operation on a directory, you should
first make sure it exists. To get this information, you can call the Directory::Exists()
method that returns a Boolean value. This method takes as argument the path to
the directory. Here is an example:
#include <windows.h>
#include "Exercise.h"
CExercise::CExercise(void)
{
InitializeComponents();
}
void CExercise::InitializeComponents()
{
Text = L"File-Based Application";
StartPosition = FormStartPosition::CenterScreen;
if( Directory::Exists("D:\\Bethesda Car Rental") )
MessageBox::Show(L"The directory exists already");
else
MessageBox::Show(L"That directory was not yet created");
}
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow)
{
Application::Run(gcnew CExercise());
return 0;
}
During the lifetime of your database, at one time, you may
want to change its location, for any reason you judge necessary. Although this
operation is primarily easily supported, it could become complex in some
scenarios. Still, to move a directory and its contents, you can call the Directory::Move()
method. This method takes two arguments: the source and the destination. After
the method has been called, the directory held by the first argument would be
moved, along with its sub-folders and files, to the path specified by the second
argument. To move a directory using the DirectoryInfo class, you can call
its MoveTo() method.
As opposed to creating a directory, if you don't need it
anymore, you can remove it. To support this, the Directory class is equipped
with the Delete() method that is overloaded with two versions. One of the
versions is used to delete a directory that is currently empty while the other
version is used to delete the directory and its content.
|
 Practical
Learning: Setting up a Directory
|
|
- On the main menu of the form, click File and double-click New
- In the top section of the file, include the System::IO namespace and
declare three variables as follows:
#pragma once
namespace GeorgetownDryCleaner1 {
using namespace System;
using namespace System::ComponentModel;
using namespace System::Collections;
using namespace System::Windows::Forms;
using namespace System::Data;
using namespace System::Drawing;
using namepace System::IO;
/// <summary>
/// Summary for Form1
///
/// WARNING: If you change the name of this class, you will need to change the
/// 'Resource File Name' property for the managed resource compiler tool
/// associated with all .resx files this class depends on. Otherwise,
/// the designers will not be able to interact properly with localized
/// resources associated with this form.
/// </summary>
public ref class Form1 : public System::Windows::Forms::Form
{
int iFilename;
bool IsNewCleaningOrder;
String ^ Filename;
public:
Form1(void)
{
InitializeComponent();
//
//TODO: Add the constructor code here
//
}
|
- Implement the event as follows:
System::Void mnuFileNew_Click(System::Object^ sender, System::EventArgs^ e)
{
// We will store our files in the following folder
String ^ strDirectory = L"C:\\Georgetown Cleaning Services\\Receipts";
DirectoryInfo ^ dirInfo = Directory::CreateDirectory(strDirectory);
// Get the list of files, if any, from our directory
array<FileInfo ^> ^ fleList = dirInfo->GetFiles();
// If there is no file in the directory,
// then we will use 1000 as the first file name
if (fleList->Length == 0)
{
iFilename = 1000;
}
else // If there was at least one file in the directory
{
// Get a reference to the last file
FileInfo ^ fleLast = fleList[fleList->Length - 1];
// Get the name of the last file without its extension
String ^ fwe = Path::GetFileNameWithoutExtension(fleLast->FullName);
// Increment the name of the file by 1
try
{
iFilename = int::Parse(fwe) + 1;
}
catch(FormatException ^)
{
}
}
// Update our global name of the file
Filename = strDirectory + L"\\" + iFilename.ToString()+ L".gcs";
txtReceiptNumber->Text = iFilename.ToString();
txtCustomerName->Text = L"";
txtCustomerPhone->Text = L"";
dtpDateLeft->Value = DateTime::Today;
dtpTimeLeft->Value = DateTime::Today;
dtpDateExpected->Value = DateTime::Today;
dtpTimeExpected->Value = DateTime::Today;
cbxStatus->Text = L"Not Yet Ready";
dtpDatePickedUp->Value = DateTime::Today;
dtpTimePickedUp->Value = DateTime::Today;
txtUnitPriceShirts->Text = L"1.25";
txtQuantityShirts->Text = L"0";
txtSubTotalShirts->Text = L"0.00";
txtUnitPricePants->Text = L"1.95";
txtQuantityPants->Text = L"0";
txtSubTotalPants->Text = L"0.00";
cbxItem1->Text = L"None";
txtUnitPriceItem1->Text = L"0.00";
txtQuantityItem1->Text = L"0";
txtSubTotalItem1->Text = L"0.00";
cbxItem2->Text = L"None";
txtUnitPriceItem2->Text = L"0.00";
txtQuantityItem2->Text = L"0";
txtSubTotalItem2->Text = L"0.00";
cbxItem3->Text = L"None";
txtUnitPriceItem3->Text = L"0.00";
txtQuantityItem3->Text = L"0";
txtSubTotalItem3->Text = L"0.00";
cbxItem4->Text = L"None";
txtUnitPriceItem4->Text = L"0.00";
txtQuantityItem4->Text = L"0";
txtSubTotalItem4->Text = L"0.00";
txtCleaningTotal->Text = L"0.00";
txtTaxRate->Text = L"7.75";
txtTaxAmount->Text = L"0.00";
txtCleaningTotal->Text = L"0.00";
txtCustomerName->Focus();
}
|
- Return to the form
|
