# 認識 C#
資料來源：
1. ChatGPT
2. [GrandmaCan -我阿嬤都會](https://www.youtube.com/watch?v=T9BeejD3i0g&t=4516s)
可以將 C# 比作一種工具，用來告訴電腦該做什麼。
C#（發音為 "C-Sharp"）是一種現代的程式設計語言，由微軟公司開發。它可以用來創建各種應用程式，包括桌面應用程式、網頁應用程式、移動應用程式和遊戲。
## 程式設計語言
- **說明**：程式設計語言就像是一種語言，可以用來給電腦下指令。就像我們使用中文或英文來交流一樣，程式設計語言用來和電腦交流。
- **比喻**：想像你正在給一個廚師下指令如何做一道菜。你需要告訴他步驟，比如先切菜、再炒菜。程式設計語言就是這些步驟的書面版本，告訴電腦該做什麼。
## 基本概念
1. **變數**
- **說明**：變數就像是存放資訊的小盒子。你可以給這個盒子取個名字，然後把資訊存放在裡面。
- **比喻**：想像你有一個標籤為 "年齡" 的盒子，裡面放著你的年齡 25。
- **示例**：
```csharp
int age = 25; // "age" 是盒子的名字，"25" 是存放在裡面的資訊
```
2. **資料型態**
- **說明**：資料型態告訴電腦你存放的資訊是什麼類型，比如數字、文字等。
- **比喻**：就像不同的盒子用來存放不同的物品，比如鞋盒用來存鞋子，文具盒用來存放筆。
- **常見資料型態**：
- `int`（整數）：存放數字，比如 25。
- `string`（字串）：存放文字，比如 "Hello, World!"。
- `bool`（布林值）：存放真或假的值，比如 `true` 或 `false`。
3. **條件語句**
- **說明**：條件語句用來根據不同的情況執行不同的操作。
- **比喻**：就像如果下雨了，你會帶傘；如果天晴，你會戴帽子。
- **示例**：
```csharp
if (isRaining)
{
Console.WriteLine("帶傘");
}
else
{
Console.WriteLine("戴帽子");
}
```
4. **迴圈**
- **說明**：迴圈用來重複執行某些操作，直到達到某個條件。
- **比喻**：就像你每天早上刷牙，這是一個每天重複的動作。
- **示例**：
```csharp
for (int i = 0; i < 5; i++)
{
Console.WriteLine("刷牙");
}
```
5. **方法**
- **說明**：方法是一組可以重複使用的指令，類似於一個小程式。
- **比喻**：想像你有一個食譜，每次你想做這道菜時，你只需要跟著食譜做就可以了。
- **示例**：
```csharp
void SayHello()
{
Console.WriteLine("Hello, World!");
}
```
## 範例程式
以下是一個簡單的 C# 範例程式，它顯示 "Hello, World!" 並計算兩個數字的和：
```csharp
using System;
class Program
{
static void Main()
{
// 顯示問候語
Console.WriteLine("Hello, World!");
// 宣告變數
int number1 = 10;
int number2 = 20;
// 計算和
int sum = number1 + number2;
// 顯示結果
Console.WriteLine("The sum is: " + sum);
}
}
```
## 總結
C# 是一種用來告訴電腦該做什麼的語言。它可以讓你創建各種應用程式。通過變數、資料型態、條件語句、迴圈和方法等概念，你可以構建和運行複雜的程式。就像學習任何語言一樣，程式設計語言需要時間和練習，但它可以開啟創造力的大門，讓你創造出令人驚奇的應用程式和遊戲。
# C# 專案目錄架構
為了幫助不懂程式的人理解 C# 專案目錄架構，我們可以把它比作一個大型的文件夾系統，每個文件夾和文件都有特定的用途。以下是詳細的說明，並以一個股票下單專案為例。
## C# 專案目錄架構
### 1. 專案根目錄
這是你專案的主文件夾，包含所有相關的文件和子文件夾，就像是一本書的主封面。
### 2. `*.csproj` 文件
這是專案文件，包含專案的配置信息，比如引用的庫和編譯選項。這就像是書的目錄或索引。
### 3. `Program.cs`
這是程式的入口點。當你運行程式時，電腦會從這裡開始讀取指令。這就像是書的第一章。
### 4. `Properties` 文件夾
這裡包含專案的配置文件，比如 `launchSettings.json`，設定如何啟動應用程式。這相當於書的出版信息。
### 5. `bin` 文件夾
這裡包含編譯後生成的可執行文件和其他輸出文件。這就像是書的成品。
### 6. `obj` 文件夾
這是中間文件夾，包含編譯過程中生成的臨時文件。這相當於書的草稿或便箋。
### 7. `Models` 文件夾
這裡包含數據模型文件，定義應用程式的數據結構。這相當於書中的數據表或統計資料。
### 8. `Controllers` 文件夾
這裡包含控制器文件，用來處理用戶請求。這相當於書的不同章節，處理不同的主題。
### 9. `Views` 文件夾
這裡包含視圖文件，用來呈現用戶界面。這相當於書中的插圖或圖表。
## 股票下單專案目錄架構範例
假設我們有一個簡單的股票下單應用程式，這是一個 ASP.NET Core 專案。下面是該專案的目錄架構：
```
StockOrderApp
├── StockOrderApp.csproj
├── Program.cs
├── Properties
│ └── launchSettings.json
├── bin
│ └── Debug
│ └── net6.0
│ └── StockOrderApp.dll
├── obj
│ └── Debug
│ └── net6.0
│ └── StockOrderApp.csproj.AssemblyInfo.cs
├── Models
│ └── Order.cs
│ └── Stock.cs
├── Controllers
│ └── OrderController.cs
│ └── StockController.cs
└── Views
├── Order
│ └── Index.cshtml
│ └── Create.cshtml
└── Stock
└── Index.cshtml
└── Details.cshtml
```
## 說明
1. **`StockOrderApp` 文件夾**
- 專案的根目錄，包含所有相關文件和子文件夾。
2. **`StockOrderApp.csproj` 文件**
- 專案文件，包含專案的配置信息，比如引用的庫和編譯選項。
3. **`Program.cs` 文件**
- 程式入口點，包含主函數 `Main`，是程式開始執行的地方。
4. **`Properties` 文件夾**
- 配置文件夾，包含 `launchSettings.json` 文件，用來設定應用程式的啟動配置。
5. **`bin` 文件夾**
- 編譯後的輸出文件夾，包含可執行文件。
6. **`obj` 文件夾**
- 中間文件夾，包含編譯過程中的臨時文件。
7. **`Models` 文件夾**
- 包含數據模型文件，例如 `Order.cs` 和 `Stock.cs`，用來定義股票和訂單的數據結構。
8. **`Controllers` 文件夾**
- 包含控制器文件，例如 `OrderController.cs` 和 `StockController.cs`，用來處理用戶的請求並執行相應的業務邏輯。
9. **`Views` 文件夾**
- 包含視圖文件，用來呈現用戶界面，例如 `Order` 和 `Stock` 文件夾下的各種 `*.cshtml` 文件，用來顯示訂單和股票的相關頁面。
## 總結
這個股票下單專案的目錄架構展示了如何組織和管理一個 C# 專案的各個部分。通過這樣的組織結構，你可以清晰地分離和管理專案的不同功能和部分，使開發工作更加有條理和高效。每個文件夾和文件都有特定的用途，這樣可以幫助你快速找到和管理你的程式碼。
# 常見資料型態 ＆ 變數
當你向不懂程式的人解釋 C# 的常見資料型態和變數時，可以使用一些簡單的比喻和實際生活中的例子來幫助他們理解。以下是一些常見資料型態及其說明和示例：
## 資料型態
1. **整數 (int)**
- **說明**：整數是沒有小數點的數字，比如 1、2、100 等。
- **例子**：想像你在數你有多少本書。如果你有 5 本書，你就可以用整數來表示這個數量。
- **C# 中的表示**：
```csharp
int numberOfBooks = 5;
```
2. **浮點數 (double)**
- **說明**：浮點數是有小數點的數字，比如 3.14、0.5、100.75 等。
- **例子**：想像你在計算你的銀行帳戶餘額。你的餘額可能是 1234.56 元。
- **C# 中的表示**：
```csharp
double bankBalance = 1234.56;
```
3. **字元 (char)**
- **說明**：字元是一個單一的字母、數字或符號，比如 'A'、'1'、'@' 等。
- **例子**：想像你在寫一個簡單的郵件標題。每個字母都是一個字元。
- **C# 中的表示**：
```csharp
char initial = 'A';
```
4. **字串 (string)**
- **說明**：字串是一組文字，通常由多個字元組成，比如 "Hello, World!"。
- **例子**：想像你在寫一封信，整封信的內容就是一個字串。
- **C# 中的表示**：
```csharp
string greeting = "Hello, World!";
```
- **補充說明**：若要在字串內換行可以使用 "Hello \n World!"，`\n` 就是換行的意思，如果要在字串裡顯示雙引號則是使用 `\"`，這就是告訴電腦 \ 後面的 " 也是一個字串。
5. **布林值 (bool)**
- **說明**：布林值表示真或假，只有兩個可能的值：`true` 或 `false`。
- **例子**：想像你在回答一個簡單的問題，比如 "今天是星期五嗎？" 答案要麼是 "是" (true)，要麼是 "不是" (false)。
- **C# 中的表示**：
```csharp
bool isFriday = false;
```
## 變數
變數就像是給某個數值、文字或其他資料類型的一個名字。這個名字可以讓你在程式中輕鬆地引用這些資料。
1. **宣告變數**：
在 C# 中，你需要先宣告變數，然後才能使用它。宣告變數時，你需要指定變數的資料型態和名稱。
- **整數變數**：
```csharp
int age = 25; // 宣告一個名為 age 的整數變數，並將其值設為 25
```
- **浮點數變數**：
```csharp
double height = 1.75; // 宣告一個名為 height 的浮點數變數，並將其值設為 1.75
```
- **字元變數**：
```csharp
char grade = 'A'; // 宣告一個名為 grade 的字元變數，並將其值設為 'A'
```
- **字串變數**：
```csharp
string name = "Alice"; // 宣告一個名為 name 的字串變數，並將其值設為 "Alice"
```
- **布林變數**：
```csharp
bool isMarried = true; // 宣告一個名為 isMarried 的布林變數，並將其值設為 true
```
2. **使用變數**：
你可以在程式中使用這些變數來執行各種操作，比如顯示資訊、計算數值等。
- **顯示資訊**：
```csharp
Console.WriteLine("Name: " + name);
Console.WriteLine("Age: " + age);
Console.WriteLine("Height: " + height);
Console.WriteLine("Grade: " + grade);
Console.WriteLine("Married: " + isMarried);
```
3. **變數運算**：
你可以對變數進行各種運算，比如加法、減法、乘法和除法。
- **例子**：
```csharp
int a = 10;
int b = 20;
int sum = a + b; // 將 a 和 b 的和存儲在 sum 變數中
Console.WriteLine("Sum: " + sum); // 顯示 sum 的值
```
## 總結
C# 中的常見資料型態和變數就像是存放不同類型資訊的容器。整數可以存放書本數量，浮點數可以存放帳戶餘額，字元可以存放單個字母，字串可以存放整段文字，布林值可以存放簡單的真或假答案。變數則是這些容器的名字，讓你可以在程式中輕鬆引用和操作這些資訊。
# 字串常見用法
C# 字串的常見用法可以比喻成處理日常文字的一些操作，像是寫信、填表格、找關鍵字等。以下是詳細的說明和範例，幫助人理解 C# 字串的基本概念和常見用法。
## 1. 字串的宣告與賦值
字串在程式裡用來存放文字資料，就像是在日常生活中用筆記本記錄文字。
### 例子：
```csharp
string greeting = "Hello, World!";
```
## 2. 字串的連接
把多個字串合併在一起，就像是把幾段話拼成一篇文章。
### 例子：
```csharp
string firstName = "John";
string lastName = "Doe";
string fullName = firstName + " " + lastName;
Console.WriteLine(fullName); // 輸出: John Doe
```
## 3. 字串的插值
在字串中插入變數的值，就像是在信中填寫收件人的名字。
### 例子：
```csharp
int age = 30;
string name = "John";
string message = $"My name is {name} and I am {age} years old.";
Console.WriteLine(message); // 輸出: My name is John and I am 30 years old.
```
## 4. 字串的長度
獲取字串的長度，就像是數一段話有多少個字。
### 例子：
```csharp
string example = "Hello, World!";
int length = example.Length;
Console.WriteLine(length); // 輸出: 13
```
## 5. 字串的比較
比較兩個字串是否相同，就像是檢查兩份文件內容是否一樣。
### 例子：
```csharp
string word1 = "apple";
string word2 = "apple";
bool areEqual = word1 == word2;
Console.WriteLine(areEqual); // 輸出: True
```
## 6. 字串的分割
把一個字串分割成多個部分，就像是把一段話按標點符號分成幾個句子。
### 例子：
```csharp
string fruits = "apple,banana,cherry";
string[] fruitArray = fruits.Split(',');
foreach (string fruit in fruitArray)
{
Console.WriteLine(fruit);
}
// 輸出:
// apple
// banana
// cherry
```
## 7. 字串的替換
在字串中替換特定的部分，就像是在文章中修改某個詞。
### 例子：
```csharp
string original = "I love apples.";
string modified = original.Replace("apples", "bananas");
Console.WriteLine(modified); // 輸出: I love bananas.
```
## 8. 字串的截取
從字串中提取特定部分，就像是從一篇文章中摘抄一段話。
### 例子：
```csharp
string sentence = "Hello, World!";
string sub = sentence.Substring(7, 5);
Console.WriteLine(sub); // 輸出: World
```
## 9. 獲取字串中特定位置的字符
在 C# 中，可以使用索引（Index）來獲取字串中指定位置的字符。這就像是知道某段文字中第幾個字是什麼。下面是詳細的說明和範例：
### 例子：
```csharp
string example = "Hello, World!";
char fifthChar = example[4]; // 索引從0開始，所以第5個字符是索引4處的字符
Console.WriteLine(fifthChar); // 輸出: o
```
## 進一步說明
如果你想知道字串中每個位置的字符，可以使用 `for` 迴圈來遍歷字串。這樣你可以看到每個字符的索引和對應的字符。
### 例子：
```csharp
string example = "Hello, World!";
for (int i = 0; i < example.Length; i++)
{
Console.WriteLine($"Character at index {i} is {example[i]}");
}
// 輸出:
// Character at index 0 is H
// Character at index 1 is e
// Character at index 2 is l
// Character at index 3 is l
// Character at index 4 is o
// Character at index 5 is ,
// Character at index 6 is
// Character at index 7 is W
// Character at index 8 is o
// Character at index 9 is r
// Character at index 10 is l
// Character at index 11 is d
// Character at index 12 is !
```
這個範例使用 `for` 迴圈來遍歷字串，並在每個迴圈中使用索引來獲取對應位置的字符，然後輸出每個字符及其索引。
## 10. 用值找位置
在 C# 中，你可以使用 `IndexOf` 方法來查找字串中某個字符或子字串的位置。這就像是在一段文字中找一個詞或字第一次出現的位置。以下是詳細的說明和範例：
#### 例子：
```csharp
string example = "Hello, World!";
int position = example.IndexOf('o');
Console.WriteLine(position); // 輸出: 4
```
### 詳細說明
1. **字串宣告與賦值**：先宣告並賦值一個字串變數 `example`。
```csharp
string example = "Hello, World!";
```
2. **使用 `IndexOf` 方法查找字符位置**：使用 `IndexOf` 方法來查找字符 `'o'` 在字串中第一次出現的位置。
```csharp
int position = example.IndexOf('o');
```
3. **輸出結果**：使用 `Console.WriteLine` 輸出結果，顯示在控制台上。
```csharp
Console.WriteLine(position); // 輸出: 4
```
### 查找子字串的位置
你也可以使用 `IndexOf` 方法來查找子字串在主字串中第一次出現的位置。
#### 例子：
```csharp
string example = "Hello, World!";
int position = example.IndexOf("World");
Console.WriteLine(position); // 輸出: 7
```
### 處理找不到的情況
如果字串中不包含要查找的字符或子字串，`IndexOf` 方法會返回 -1。
#### 例子：
```csharp
string example = "Hello, World!";
int position = example.IndexOf('z');
Console.WriteLine(position); // 輸出: -1
```
### 查找最後一次出現的位置
如果你想查找某個字符或子字串最後一次出現的位置，可以使用 `LastIndexOf` 方法。
#### 例子：
```csharp
string example = "Hello, World!";
int position = example.LastIndexOf('o');
Console.WriteLine(position); // 輸出: 8
```
## 總結
C# 字串的常見用法就像是處理日常文字操作一樣，有宣告與賦值、連接、插值、比較、分割、替換和截取等功能。這些操作讓我們可以靈活地處理和操作文字資料，滿足不同的應用需求。
這樣的說明和範例應該能幫助不懂程式的人理解 C# 字串的基本概念和常見用法。
# 數字常見用法（整數 浮點數）
在程式設計中，數字是非常重要的一部分。C# 中的數字可以分為整數和浮點數。讓我們先了解它們各自的用途，然後再舉一些在金融證券業中常見的例子。
### 整數（Integer）
整數是沒有小數點的數字，適合用來表示計數、序號等。
### 浮點數（Floating-Point Number）
浮點數是帶有小數點的數字，適合用來表示精確度要求較高的數據，如價格、利率等。
## 1. 整數（Integer）
### 常見用法
- **宣告與賦值**：定義一個整數變數並賦值。
```csharp
int age = 30;
```
- **基本運算**：可以對整數進行加減乘除運算。
```csharp
int a = 5;
int b = 3;
int sum = a + b; // 加法
int difference = a - b; // 減法
int product = a * b; // 乘法
int quotient = a / b; // 除法
```
### 金融證券業常見例子
- **股票數量**：表示一個人持有的某種股票的數量。
```csharp
int numberOfShares = 100;
```
- **交易次數**：表示某段時間內的交易次數。
```csharp
int numberOfTransactions = 50;
```
## 2. 浮點數（Floating-Point Number）
### 常見用法
- **宣告與賦值**：定義一個浮點數變數並賦值。
```csharp
double price = 123.45;
```
- **基本運算**：可以對浮點數進行加減乘除運算。
```csharp
double x = 5.5;
double y = 3.2;
double sum = x + y; // 加法
double difference = x - y; // 減法
double product = x * y; // 乘法
double quotient = x / y; // 除法
```
### 金融證券業常見例子
- **股票價格**：表示某隻股票的價格。
```csharp
double stockPrice = 250.75;
```
- **投資金額**：表示一筆投資的金額。
```csharp
double investmentAmount = 10000.50;
```
- **利率**：表示某種投資的年利率。
```csharp
double annualInterestRate = 0.05; // 5%
```
## 總結
整數和浮點數是程式設計中常見的數據類型。在金融證券業中，整數通常用來表示股票數量、交易次數等沒有小數的數據；而浮點數則用來表示價格、利率等需要精確到小數點的數據。掌握這些基本的數據類型和用法，能夠更好地處理和分析金融數據。
## 詳細範例
讓我們來看看一個綜合的範例，展示如何在金融證券業中使用整數和浮點數：
```csharp
using System;
class Program
{
static void Main()
{
// 股票數量
int numberOfShares = 100;
// 股票價格
double stockPrice = 250.75;
// 總投資金額
double totalInvestment = numberOfShares * stockPrice;
// 顯示結果
Console.WriteLine("持有股票數量: " + numberOfShares);
Console.WriteLine("每股價格: $" + stockPrice);
Console.WriteLine("總投資金額: $" + totalInvestment);
}
}
```
### 輸出結果：
```
持有股票數量: 100
每股價格: $250.75
總投資金額: $25075.0
```
在這個範例中，我們計算了一個人持有的股票總投資金額。整數 `numberOfShares` 表示股票數量，浮點數 `stockPrice` 表示每股價格，然後將兩者相乘得到總投資金額 `totalInvestment`。這樣的計算在金融證券業中非常常見。
# 取得用戶輸入
在C#中，要取得使用者的輸入，通常使用`Console.ReadLine()`方法。這個方法允許程式等待使用者在命令列窗口中輸入文字，並將該文字作為字串返回，以便後續處理。
### 範例說明
在證券界常見的應用場景之一是處理交易指令。以下是一個簡單的示例，展示如何使用C#來取得使用者輸入，模擬證券交易指令的情境：
#### 範例程式碼：
```csharp
using System;
class Program
{
static void Main()
{
Console.WriteLine("歡迎使用證券交易指令模擬系統。");
Console.WriteLine("請輸入您的交易指令（例如：BUY AAPL 100）：");
// 取得使用者輸入
string userInput = Console.ReadLine();
// 解析交易指令
string[] parts = userInput.Split(' ');
if (parts.Length >= 3)
{
string action = parts[0]; // 操作類型（BUY或SELL）
string symbol = parts[1]; // 股票代號
int quantity = int.Parse(parts[2]); // 股票數量
// 執行交易
ExecuteTrade(action, symbol, quantity);
}
else
{
Console.WriteLine("交易指令格式不正確，請重新輸入。");
}
}
static void ExecuteTrade(string action, string symbol, int quantity)
{
// 這裡可以實現真實的交易執行邏輯，這裡僅作示範
Console.WriteLine($"正在執行交易：{action} {quantity} 股 {symbol}。");
Console.WriteLine("交易成功！");
}
}
```
#### 範例說明：
1. **程式啟動**：當程式啟動時，首先會顯示歡迎信息和輸入提示。
2. **取得使用者輸入**：使用 `Console.ReadLine()` 方法等待使用者在命令列窗口中輸入文字，並將輸入的內容儲存在 `userInput` 變數中。
3. **解析交易指令**：將使用者輸入的指令字串分割成多個部分，例如操作類型、股票代號和數量。這裡使用 `Split(' ')` 方法將輸入的字串根據空格分割成陣列。
4. **執行交易**：根據解析後的操作類型、股票代號和數量，呼叫 `ExecuteTrade` 方法來模擬執行交易。在實際應用中，這裡可以連接到證券交易平台，執行真實的交易操作。
5. **錯誤處理**：如果使用者輸入的格式不正確（例如缺少必要的信息），程式會提醒使用者重新輸入。
這個範例展示了如何在C#中使用 `Console.ReadLine()` 方法來取得使用者的輸入，並且如何處理和解析這些輸入以執行相應的操作，這在證券交易界中是非常常見的應用場景之一。
# 基本計算
為了結合上述的例子並且展示基本計算機功能在證券界的應用，我們將擴展原有的程式碼，增加一個基本計算機功能，使其可以計算股票的價值。
## 擴展範例程式碼：
```csharp
using System;
class Program
{
static void Main()
{
Console.WriteLine("歡迎使用證券交易指令模擬系統。");
Console.WriteLine("請輸入您的交易指令（例如：BUY AAPL 100）：");
// 取得使用者輸入
string userInput = Console.ReadLine();
// 解析交易指令
string[] parts = userInput.Split(' ');
if (parts.Length >= 3)
{
string action = parts[0]; // 操作類型（BUY或SELL）
string symbol = parts[1]; // 股票代號
int quantity = int.Parse(parts[2]); // 股票數量
// 執行交易
ExecuteTrade(action, symbol, quantity);
// 顯示計算機功能
Console.WriteLine("\n請輸入要計算的股票價格（單位價格）：");
double stockPrice = double.Parse(Console.ReadLine());
Console.WriteLine("請輸入要計算的股票數量：");
int stockQuantity = int.Parse(Console.ReadLine());
// 計算總值
double totalValue = stockPrice * stockQuantity;
Console.WriteLine($"股票總值為：${totalValue}");
}
else
{
Console.WriteLine("交易指令格式不正確，請重新輸入。");
}
}
static void ExecuteTrade(string action, string symbol, int quantity)
{
// 這裡可以實現真實的交易執行邏輯，這裡僅作示範
Console.WriteLine($"正在執行交易：{action} {quantity} 股 {symbol}。");
Console.WriteLine("交易成功！");
}
}
```
## 擴展範例說明：
1. **程式啟動**：與之前一樣，程式啟動時會顯示歡迎信息和輸入提示。
2. **交易指令處理**：使用者可以輸入交易指令，例如 "BUY AAPL 100"，程式將解析這個指令並執行相應的交易。
3. **計算機功能**：在交易指令處理完成後，程序會提示使用者輸入股票的單位價格和數量，然後計算股票的總值。這裡使用 `Console.ReadLine()` 方法取得使用者輸入的數字，並使用 `double.Parse()` 和 `int.Parse()` 方法將其轉換成相應的數值型別。
4. **顯示結果**：計算完股票總值後，程式會將結果輸出到命令列窗口中。
這個擴展示例展示了如何在C#中結合基本的證券交易指令處理和基本計算機功能。在證券界，交易員可能需要根據股票的單位價格和數量計算出具體的交易金額或股票價值，這個範例展示了如何使用簡單的程式碼實現這些功能。
## 將字串換成整數
當然，我們可以使用 `System.Convert.ToInt32()` 方法來將使用者輸入的字串轉換為整數。這樣可以確保程式在接收使用者輸入時能夠正確地處理數字轉換，避免因為格式不正確而產生錯誤。
下面是擴展後的範例程式碼：
```csharp
using System;
class Program
{
static void Main()
{
Console.WriteLine("歡迎使用證券交易指令模擬系統。");
Console.WriteLine("請輸入您的交易指令（例如：BUY AAPL 100）：");
// 取得使用者輸入
string userInput = Console.ReadLine();
// 解析交易指令
string[] parts = userInput.Split(' ');
if (parts.Length >= 3)
{
string action = parts[0]; // 操作類型（BUY或SELL）
string symbol = parts[1]; // 股票代號
int quantity = int.Parse(parts[2]); // 股票數量
// 執行交易
ExecuteTrade(action, symbol, quantity);
// 顯示計算機功能
Console.WriteLine("\n請輸入要計算的股票價格（單位價格）：");
double stockPrice = double.Parse(Console.ReadLine());
Console.WriteLine("請輸入要計算的股票數量：");
int stockQuantity = System.Convert.ToInt32(Console.ReadLine());
// 計算總值
double totalValue = stockPrice * stockQuantity;
Console.WriteLine($"股票總值為：${totalValue}");
}
else
{
Console.WriteLine("交易指令格式不正確，請重新輸入。");
}
}
static void ExecuteTrade(string action, string symbol, int quantity)
{
// 這裡可以實現真實的交易執行邏輯，這裡僅作示範
Console.WriteLine($"正在執行交易：{action} {quantity} 股 {symbol}。");
Console.WriteLine("交易成功！");
}
}
```
### 修改說明：
1. **計算機功能修改**：在請求使用者輸入股票數量的地方，使用 `System.Convert.ToInt32(Console.ReadLine())` 方法來將使用者輸入的文字轉換為整數。這樣做可以確保程式能夠處理使用者正確輸入的數字，並且在無法轉換時能夠產生適當的錯誤處理。
這個擴展後的範例演示了如何使用 `System.Convert.ToInt32()` 方法來安全地處理使用者輸入，同時展示了基本的證券交易指令處理和計算機功能。
# 陣列 Array
在 C# 中，陣列（Array）是一種資料結構，可以儲存多個相同型別的值。陣列的每個元素都有一個索引，可以通過這個索引來存取元素。陣列的索引從 0 開始，也就是說，第一個元素的索引是 0，第二個元素的索引是 1，以此類推。
## C# 陣列的基本使用方式
1. **宣告和初始化陣列**：
- 宣告：指定陣列的型別和名稱。
- 初始化：給陣列分配記憶體空間並賦予初始值。
```csharp
int[] numbers = new int[5]; // 宣告一個可以存放5個整數的陣列
numbers[0] = 10; // 設定第一個元素的值為10
numbers[1] = 20; // 設定第二個元素的值為20
// 可以依此類推設置其他元素的值
```
2. **快速初始化陣列**：
```csharp
int[] numbers = { 10, 20, 30, 40, 50 }; // 宣告並初始化一個陣列
```
3. **存取陣列元素**：
```csharp
int firstNumber = numbers[0]; // 取得陣列的第一個元素
int secondNumber = numbers[1]; // 取得陣列的第二個元素
```
## 在證券界的應用範例
假設我們在證券界需要儲存某個股票在一週內的每日收盤價，並計算這些收盤價的平均值。這是一個常見的需求，可以利用陣列來實現。
## 範例程式碼：
```csharp
using System;
class Program
{
static void Main()
{
// 宣告並初始化一個陣列來存放某股票在一週內的每日收盤價
double[] closingPrices = { 150.5, 152.3, 148.7, 149.8, 151.2 };
// 計算收盤價的總和
double sum = 0;
for (int i = 0; i < closingPrices.Length; i++)
{
sum += closingPrices[i];
}
// 計算平均值
double averagePrice = sum / closingPrices.Length;
// 輸出結果
Console.WriteLine("某股票在一週內的收盤價：");
for (int i = 0; i < closingPrices.Length; i++)
{
Console.WriteLine($"第{i + 1}天：{closingPrices[i]}");
}
Console.WriteLine($"平均收盤價：{averagePrice}");
// 額外應用：找出最高和最低收盤價
double highestPrice = closingPrices[0];
double lowestPrice = closingPrices[0];
for (int i = 1; i < closingPrices.Length; i++)
{
if (closingPrices[i] > highestPrice)
{
highestPrice = closingPrices[i];
}
if (closingPrices[i] < lowestPrice)
{
lowestPrice = closingPrices[i];
}
}
Console.WriteLine($"最高收盤價：{highestPrice}");
Console.WriteLine($"最低收盤價：{lowestPrice}");
}
}
```
## 範例說明：
1. **宣告並初始化陣列**：
- `double[] closingPrices = { 150.5, 152.3, 148.7, 149.8, 151.2 };`
- 這行程式碼宣告了一個 `double` 型別的陣列，並將其初始化為一週內的五個收盤價。
2. **計算總和**：
- 使用一個 `for` 迴圈遍歷陣列中的每個元素，並累加到 `sum` 變數中。
3. **計算平均值**：
- 將總和除以陣列的長度（即元素的個數），得到平均收盤價。
4. **輸出結果**：
- 使用另一個 `for` 迴圈輸出每一天的收盤價。
- 最後輸出計算得到的平均收盤價。
5. **找出最高和最低收盤價**：
- 初始化 `highestPrice` 和 `lowestPrice` 為陣列的第一個元素。
- 使用 `for` 迴圈比較每個元素，更新最高和最低價格。
這個範例展示了如何使用陣列來儲存和處理股票收盤價，並進行基本的計算和分析，這些技能在證券界的日常工作中是非常實用的。
## 在不確定陣列內的值時
如果在初始化時不確定陣列的大小，或者需要在程式執行過程中動態地添加或移除元素，C# 提供了一些更適合的集合類型，例如：`string[] num = new string[]`，創建一個空的陣列並且限制只能放10個值或是使用`List<T>`。`List<T>` 是一個泛型集合類型，可以根據需要動態地調整其大小。
### 使用 `List<T>` 處理動態數據
我們可以用 `List<double>` 來存儲不確定數量的股票收盤價。`List<T>` 提供了許多方便的方法來添加、移除和操作元素。
### 範例程式碼：
```csharp
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
// 宣告一個 List 來存放某股票的收盤價
List<double> closingPrices = new List<double>();
// 模擬動態添加收盤價
closingPrices.Add(150.5);
closingPrices.Add(152.3);
closingPrices.Add(148.7);
closingPrices.Add(149.8);
closingPrices.Add(151.2);
// 也可以通過循環來添加用戶輸入的收盤價
Console.WriteLine("請輸入股票的收盤價，輸入 'done' 表示結束：");
while (true)
{
string input = Console.ReadLine();
if (input.ToLower() == "done")
{
break;
}
if (double.TryParse(input, out double price))
{
closingPrices.Add(price);
}
else
{
Console.WriteLine("請輸入有效的數字或 'done' 結束輸入。");
}
}
// 計算收盤價的總和
double sum = 0;
foreach (double price in closingPrices)
{
sum += price;
}
// 計算平均值
double averagePrice = sum / closingPrices.Count;
// 輸出結果
Console.WriteLine("某股票的收盤價：");
foreach (double price in closingPrices)
{
Console.WriteLine($"收盤價：{price}");
}
Console.WriteLine($"平均收盤價：{averagePrice}");
// 額外應用：找出最高和最低收盤價
double highestPrice = closingPrices[0];
double lowestPrice = closingPrices[0];
foreach (double price in closingPrices)
{
if (price > highestPrice)
{
highestPrice = price;
}
if (price < lowestPrice)
{
lowestPrice = price;
}
}
Console.WriteLine($"最高收盤價：{highestPrice}");
Console.WriteLine($"最低收盤價：{lowestPrice}");
}
}
```
### 範例說明：
1. **宣告 `List<double>`**：
- `List<double> closingPrices = new List<double>();`
- 這行程式碼宣告並初始化了一個可以動態調整大小的 `List<double>`。
2. **動態添加元素**：
- 使用 `closingPrices.Add(150.5);` 將收盤價添加到 `List` 中。
- 也可以通過循環和用戶輸入來動態添加收盤價。
3. **計算總和和平均值**：
- 使用 `foreach` 迴圈遍歷 `List` 中的每個元素，計算總和。
- 計算平均值時，使用 `closingPrices.Count` 來獲取 `List` 中元素的數量。
4. **輸出結果**：
- 使用 `foreach` 迴圈輸出每個收盤價。
- 計算並輸出平均收盤價、最高和最低收盤價。
這樣的動態數據處理方式更加靈活，適合處理在運行時不確定大小的數據集合，這在金融證券業務中是非常常見的情況。
# if 判斷句
`if` 判斷句是程式設計中常見的一種控制流結構，用來根據條件來決定是否執行某段程式碼。在 C# 中，`if` 判斷句可以用來處理各種邏輯條件，例如比較數字、檢查字串是否相等等。
## `if` 判斷句的基本語法
```csharp
if (條件)
{
// 當條件為真時執行的程式碼
}
```
## 範例：股票交易中的 `if` 判斷句
在證券交易中，投資者經常需要根據某些條件來決定是否買入或賣出股票。以下是一個簡單的例子，說明如何使用 `if` 判斷句來實現這一需求。
假設我們有一個簡單的程式，可以根據股票的當前價格來決定是否買入或賣出股票：
```csharp
using System;
class Program
{
static void Main()
{
double stockPrice = 100.5; // 當前股票價格
double buyThreshold = 95.0; // 買入門檻價
double sellThreshold = 105.0; // 賣出門檻價
// 判斷是否買入股票
if (stockPrice < buyThreshold)
{
Console.WriteLine("當前價格低於買入門檻，建議買入股票。");
}
// 判斷是否賣出股票
if (stockPrice > sellThreshold)
{
Console.WriteLine("當前價格高於賣出門檻，建議賣出股票。");
}
// 若價格在買入與賣出門檻之間
if (stockPrice >= buyThreshold && stockPrice <= sellThreshold)
{
Console.WriteLine("當前價格在門檻範圍內，建議持有股票。");
}
}
}
```
## 使用 `else if` 和 `else`
在更多條件判斷的情況下，可以使用 `else if` 和 `else` 來處理不同的情況：
```csharp
using System;
class Program
{
static void Main()
{
double stockPrice = 100.5; // 當前股票價格
double buyThreshold = 95.0; // 買入門檻價
double sellThreshold = 105.0; // 賣出門檻價
// 判斷買入、賣出或持有
if (stockPrice < buyThreshold)
{
Console.WriteLine("當前價格低於買入門檻，建議買入股票。");
}
else if (stockPrice > sellThreshold)
{
Console.WriteLine("當前價格高於賣出門檻，建議賣出股票。");
}
else
{
Console.WriteLine("當前價格在門檻範圍內，建議持有股票。");
}
}
}
```
## 更優化的判斷結構
在某些情況下，我們可以進一步優化判斷結構，例如使用 `switch` 語句來替代多個 `if-else if` 結構：
```csharp
using System;
class Program
{
static void Main()
{
double stockPrice = 100.5; // 當前股票價格
double buyThreshold = 95.0; // 買入門檻價
double sellThreshold = 105.0; // 賣出門檻價
string action = string.Empty;
// 判斷買入、賣出或持有
if (stockPrice < buyThreshold)
{
action = "buy";
}
else if (stockPrice > sellThreshold)
{
action = "sell";
}
else
{
action = "hold";
}
// 使用 switch 來處理不同的操作
switch (action)
{
case "buy":
Console.WriteLine("當前價格低於買入門檻，建議買入股票。");
break;
case "sell":
Console.WriteLine("當前價格高於賣出門檻，建議賣出股票。");
break;
case "hold":
Console.WriteLine("當前價格在門檻範圍內，建議持有股票。");
break;
default:
Console.WriteLine("無法判斷操作。");
break;
}
}
}
```
這些範例展示了如何使用 `if` 判斷句及其變體來處理不同的條件，在金融證券業中非常常見。這些邏輯可以幫助投資者做出明智的交易決策。
### 進階用法
如果要讓用戶自行輸入買入價格，可以使用 `Console.ReadLine` 方法來獲取用戶的輸入，並將其轉換為數字。這裡提供一個例子，展示如何在股票交易範例中加入用戶輸入功能：
### 完整範例：使用 `Console.ReadLine` 獲取用戶輸入
```csharp
using System;
class Program
{
static void Main()
{
// 取得當前股票價格（可以是從外部系統獲取的即時數據）
double stockPrice = 100.5;
// 輸入買入門檻價
Console.WriteLine("請輸入買入門檻價：");
string buyInput = Console.ReadLine();
double buyThreshold;
// 驗證輸入是否為有效數字
while (!double.TryParse(buyInput, out buyThreshold))
{
Console.WriteLine("無效的輸入，請輸入一個數字：");
buyInput = Console.ReadLine();
}
// 輸入賣出門檻價
Console.WriteLine("請輸入賣出門檻價：");
string sellInput = Console.ReadLine();
double sellThreshold;
// 驗證輸入是否為有效數字
while (!double.TryParse(sellInput, out sellThreshold))
{
Console.WriteLine("無效的輸入，請輸入一個數字：");
sellInput = Console.ReadLine();
}
// 判斷買入、賣出或持有
if (stockPrice < buyThreshold)
{
Console.WriteLine("當前價格低於買入門檻，建議買入股票。");
}
else if (stockPrice > sellThreshold)
{
Console.WriteLine("當前價格高於賣出門檻，建議賣出股票。");
}
else
{
Console.WriteLine("當前價格在門檻範圍內，建議持有股票。");
}
}
}
```
### 說明
1. **讀取輸入**：
- 使用 `Console.ReadLine()` 來讀取用戶的輸入，這會返回一個字符串。
- 使用 `double.TryParse()` 將字符串轉換為數字，並檢查輸入是否有效。如果無效，則提示用戶重新輸入。
2. **循環驗證輸入**：
- 使用 `while` 迴圈來反覆檢查用戶的輸入，直到輸入一個有效的數字為止。
3. **判斷邏輯**：
- 判斷邏輯與之前的範例相同，根據用戶輸入的買入和賣出門檻來決定是否買入、賣出或持有股票。
這樣的設計確保了用戶可以自行輸入買入和賣出門檻，並且能夠處理無效的輸入，增強了程式的健壯性和實用性。
# 總複習
複習 C# 中的基本概念，並舉出一個證券業界常見的例子來說明如何使用這些概念。
## 基本概念
### 1. 變數
變數是用來儲存資料的容器。在 C# 中，你可以用變數來儲存各種類型的資料，如整數、浮點數、字串等等。
```csharp
int age = 30; // 整數
double price = 99.99; // 浮點數
string name = "Alice"; // 字串
```
### 2. 常見資料型態
- **整數型態 (int)**：儲存整數，例如股票的數量。
- **浮點數型態 (double)**：儲存小數，例如股票的價格。
- **字串型態 (string)**：儲存文字，例如股票名稱。
```csharp
int stockQuantity = 100;
double stockPrice = 105.50;
string stockName = "Apple";
```
### 3. `if` 判斷句
`if` 判斷句用來根據特定條件決定是否執行某段程式碼。
```csharp
if (stockPrice > 100)
{
Console.WriteLine("股票價格高於100");
}
else
{
Console.WriteLine("股票價格不高於100");
}
```
### 4. 取得用戶輸入
你可以使用 `Console.ReadLine` 來取得用戶輸入，並將其轉換為數字進行計算。
```csharp
Console.WriteLine("請輸入買入價格：");
string input = Console.ReadLine();
double buyPrice = Convert.ToDouble(input);
```
## 應用在證券業界的範例
假設我們要設計一個簡單的股票交易決策程式，根據用戶輸入的買入和賣出門檻價來決定是否買入、賣出或持有股票。
```csharp
using System;
class Program
{
static void Main()
{
// 取得當前股票價格（可以是從外部系統獲取的即時數據）
double stockPrice = 100.5;
// 輸入買入門檻價
Console.WriteLine("請輸入買入門檻價：");
string buyInput = Console.ReadLine();
double buyThreshold;
// 驗證輸入是否為有效數字
while (!double.TryParse(buyInput, out buyThreshold))
{
Console.WriteLine("無效的輸入，請輸入一個數字：");
buyInput = Console.ReadLine();
}
// 輸入賣出門檻價
Console.WriteLine("請輸入賣出門檻價：");
string sellInput = Console.ReadLine();
double sellThreshold;
// 驗證輸入是否為有效數字
while (!double.TryParse(sellInput, out sellThreshold))
{
Console.WriteLine("無效的輸入，請輸入一個數字：");
sellInput = Console.ReadLine();
}
// 判斷買入、賣出或持有
if (stockPrice < buyThreshold)
{
Console.WriteLine("當前價格低於買入門檻，建議買入股票。");
}
else if (stockPrice > sellThreshold)
{
Console.WriteLine("當前價格高於賣出門檻，建議賣出股票。");
}
else
{
Console.WriteLine("當前價格在門檻範圍內，建議持有股票。");
}
}
}
```
## 說明
1. **取得股票價格**：
- 在這個例子中，我們假設當前股票價格是 100.5。實際應用中可以從即時數據獲取系統取得。
2. **輸入買入和賣出門檻價**：
- 使用 `Console.ReadLine()` 來讓用戶輸入買入和賣出門檻價，並使用 `double.TryParse()` 驗證輸入是否為有效的數字。
3. **判斷邏輯**：
- 根據當前股票價格與用戶輸入的門檻價進行比較，決定是否建議用戶買入、賣出或持有股票。
這個範例展示了如何使用 C# 的變數、資料型態、`if` 判斷句和用戶輸入功能來實現一個簡單的股票交易決策程式，這在證券業界是非常常見的應用。
# `while` 迴圈及其應用
說明 C# 中的 `while` 迴圈，並舉出一個證券業界常見的例子來說明如何使用這個迴圈。
## 基本概念
### `while` 迴圈
`while` 迴圈是一種控制流結構，允許程式在條件為 `true` 時重複執行某段程式碼。當條件變為 `false` 時，迴圈停止。
```csharp
while (條件)
{
// 執行的程式碼
}
```
例如，我們可以使用 `while` 迴圈來重複詢問用戶輸入，直到輸入一個有效的數字：
```csharp
using System;
class Program
{
static void Main()
{
int number;
bool isValid = false;
while (!isValid)
{
Console.WriteLine("請輸入一個有效的數字：");
string input = Console.ReadLine();
isValid = int.TryParse(input, out number);
if (!isValid)
{
Console.WriteLine("無效的輸入，請再試一次。");
}
}
Console.WriteLine("你輸入的數字是：" + number);
}
}
```
## 應用在證券業界的範例
假設我們要設計一個簡單的程式，讓用戶輸入多支股票的價格，直到用戶輸入一個負數表示停止輸入，並計算這些股票價格的平均值。
```csharp
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
List<double> stockPrices = new List<double>();
double price;
while (true)
{
Console.WriteLine("請輸入股票價格（輸入負數以停止）：");
string input = Console.ReadLine();
if (!double.TryParse(input, out price) || price < 0)
{
break;
}
stockPrices.Add(price);
}
if (stockPrices.Count > 0)
{
double total = 0;
foreach (double stockPrice in stockPrices)
{
total += stockPrice;
}
double averagePrice = total / stockPrices.Count;
Console.WriteLine("你輸入的股票平均價格是：" + averagePrice);
}
else
{
Console.WriteLine("沒有輸入任何有效的股票價格。");
}
}
}
```
## 說明
1. **建立空的股票價格列表**：
- 使用 `List<double>` 來儲存用戶輸入的股票價格。
2. **重複詢問用戶輸入股票價格**：
- 使用 `while (true)` 迴圈來不斷詢問用戶輸入股票價格，直到用戶輸入一個負數來停止輸入。
- 在每次迴圈中，使用 `double.TryParse` 檢查輸入是否為有效的數字，如果不是或輸入的是負數，則跳出迴圈。
3. **計算平均價格**：
- 如果用戶輸入了一些股票價格，計算這些價格的總和並除以數量，得到平均價格。
- 如果用戶沒有輸入任何有效的股票價格，顯示提示訊息。
## 延伸與更優化
你可以進一步優化這個程式，讓它更具可讀性和功能性。例如，將重複的程式碼抽取成方法，並加入更多的輸入驗證和錯誤處理。
```csharp
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
List<double> stockPrices = GetStockPricesFromUser();
if (stockPrices.Count > 0)
{
double averagePrice = CalculateAverage(stockPrices);
Console.WriteLine("你輸入的股票平均價格是：" + averagePrice);
}
else
{
Console.WriteLine("沒有輸入任何有效的股票價格。");
}
}
static List<double> GetStockPricesFromUser()
{
List<double> stockPrices = new List<double>();
double price;
while (true)
{
Console.WriteLine("請輸入股票價格（輸入負數以停止）：");
string input = Console.ReadLine();
if (!double.TryParse(input, out price) || price < 0)
{
break;
}
stockPrices.Add(price);
}
return stockPrices;
}
static double CalculateAverage(List<double> prices)
{
double total = 0;
foreach (double price in prices)
{
total += price;
}
return total / prices.Count;
}
}
```
這個程式更具結構化，讓你更容易理解和維護程式碼。同時也展示了如何在實際應用中使用 `while` 迴圈來處理用戶輸入和數據處理，這在證券業界是非常常見的需求。
# `for` 迴圈及其應用
在這裡，我們將詳細說明 C# 中的 `for` 迴圈，並舉出一個證券業界常見的例子來說明如何使用這個迴圈。
## 基本概念
### `for` 迴圈
`for` 迴圈是一種控制流結構，允許程式在條件為 `true` 時重複執行某段程式碼。`for` 迴圈通常用於知道確切需要執行多少次的情況。
```csharp
for (初始化; 條件; 更新)
{
// 執行的程式碼
}
```
- **初始化**：設定迴圈變數的初始值。
- **條件**：每次迴圈執行前檢查的條件，如果條件為 `false`，則退出迴圈。
- **更新**：每次迴圈執行後執行的操作，通常是增加或減少迴圈變數。
例如，打印 1 到 5 的數字：
```csharp
for (int i = 1; i <= 5; i++)
{
Console.WriteLine(i);
}
```
## 應用在證券業界的範例
假設我們要設計一個程式來計算多支股票的平均價格，這些價格事先存儲在一個數組中。我們可以使用 `for` 迴圈來遍歷這個數組，計算總和，然後求平均值。
```csharp
using System;
class Program
{
static void Main()
{
// 假設股票價格存儲在一個數組中
double[] stockPrices = { 100.5, 101.2, 98.7, 105.3, 102.1 };
double total = 0;
// 使用 for 迴圈計算總和
for (int i = 0; i < stockPrices.Length; i++)
{
total += stockPrices[i];
}
// 計算平均價格
double averagePrice = total / stockPrices.Length;
// 輸出平均價格
Console.WriteLine("股票的平均價格是：" + averagePrice);
}
}
```
## 說明
1. **股票價格數組**：
- 假設我們有一個數組 `stockPrices`，其中包含多支股票的價格。
2. **計算總和**：
- 使用 `for` 迴圈遍歷這個數組，將每個價格累加到 `total` 變數中。
3. **計算平均價格**：
- 將總和除以數組的長度，得到股票的平均價格。
## 延伸與更優化
我們可以進一步優化這個程式，讓它更具彈性，例如允許用戶動態輸入股票價格，並使用 `List<double>` 來存儲價格，這樣就不需要預先知道數組的大小。
```csharp
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
List<double> stockPrices = new List<double>();
double price;
// 動態輸入股票價格
while (true)
{
Console.WriteLine("請輸入股票價格（輸入負數以停止）：");
string input = Console.ReadLine();
if (!double.TryParse(input, out price) || price < 0)
{
break;
}
stockPrices.Add(price);
}
// 使用 for 迴圈計算總和
double total = 0;
for (int i = 0; i < stockPrices.Count; i++)
{
total += stockPrices[i];
}
// 計算平均價格
if (stockPrices.Count > 0)
{
double averagePrice = total / stockPrices.Count;
Console.WriteLine("你輸入的股票平均價格是：" + averagePrice);
}
else
{
Console.WriteLine("沒有輸入任何有效的股票價格。");
}
}
}
```
## 說明
1. **動態輸入股票價格**：
- 使用 `while` 迴圈讓用戶動態輸入股票價格，並存儲到 `List<double>` 中，直到輸入一個負數為止。
2. **計算總和**：
- 使用 `for` 迴圈遍歷 `List<double>`，計算所有股票價格的總和。
3. **計算平均價格**：
- 將總和除以 `List` 的長度，得到平均價格，並輸出結果。
這個範例展示了如何使用 C# 的 `for` 迴圈來處理股票價格數據，並計算平均值，這在證券業界是非常常見的應用。
# 二維陣列及其應用
說明 C# 中的二維陣列，並舉出一個證券業界常見的例子來說明如何使用二維陣列。
## 基本概念
### 二維陣列
二維陣列是一種數據結構，它像一張表格一樣，包含行和列。在 C# 中，二維陣列可以用來存儲多個數據組，每個數據組有多個屬性。
```csharp
// 宣告一個 3x3 的二維陣列
int[,] array = new int[3, 3];
```
這裡我們宣告了一個 3 行 3 列的二維陣列，並可以使用索引來存取或設定其值：
```csharp
array[0, 0] = 1; // 設定第一行第一列的值為 1
int value = array[0, 0]; // 取出第一行第一列的值
```
## 應用在證券業界的範例
假設我們要設計一個程式來存儲多支股票在不同時間的價格，我們可以使用二維陣列來實現。
## 範例：股票價格矩陣
```csharp
using System;
class Program
{
static void Main()
{
// 假設我們有 3 支股票，在 4 個不同的時間點的價格
double[,] stockPrices = new double[3, 4]
{
{ 100.5, 101.2, 98.7, 105.3 }, // 第一支股票
{ 210.1, 215.4, 220.3, 208.7 }, // 第二支股票
{ 305.2, 310.5, 299.8, 315.1 } // 第三支股票
};
// 打印所有股票在不同時間點的價格
for (int i = 0; i < stockPrices.GetLength(0); i++) // 迴圈每支股票
{
Console.Write("股票 " + (i + 1) + " 的價格：");
for (int j = 0; j < stockPrices.GetLength(1); j++) // 迴圈每個時間點
{
Console.Write(stockPrices[i, j] + " ");
}
Console.WriteLine(); // 換行
}
}
}
```
## 說明
1. **股票價格矩陣**：
- 我們宣告一個 `double[,]` 二維陣列 `stockPrices`，並初始化每支股票在 4 個不同時間點的價格。
2. **打印所有價格**：
- 使用巢狀的 `for` 迴圈來遍歷二維陣列，打印出每支股票在每個時間點的價格。
## 延伸與更優化
我們可以進一步優化這個程式，讓它能夠動態輸入股票價格並計算每支股票的平均價格。
```csharp
using System;
class Program
{
static void Main()
{
Console.WriteLine("請輸入股票數量：");
int stockCount = int.Parse(Console.ReadLine());
Console.WriteLine("請輸入時間點數量：");
int timeCount = int.Parse(Console.ReadLine());
double[,] stockPrices = new double[stockCount, timeCount];
// 動態輸入股票價格
for (int i = 0; i < stockCount; i++)
{
for (int j = 0; j < timeCount; j++)
{
Console.WriteLine($"請輸入股票 {i + 1} 在時間點 {j + 1} 的價格：");
stockPrices[i, j] = double.Parse(Console.ReadLine());
}
}
// 計算並打印每支股票的平均價格
for (int i = 0; i < stockCount; i++)
{
double total = 0;
for (int j = 0; j < timeCount; j++)
{
total += stockPrices[i, j];
}
double averagePrice = total / timeCount;
Console.WriteLine($"股票 {i + 1} 的平均價格是：{averagePrice}");
}
}
}
```
### 說明
1. **動態輸入**：
- 用戶輸入股票數量和時間點數量，然後依次輸入每支股票在每個時間點的價格。
- 我們使用巢狀的 `for` 迴圈來讀取這些輸入並存儲在二維陣列中。
2. **計算平均價格**：
- 使用巢狀的 `for` 迴圈來遍歷每支股票的價格，計算總和並求平均值，然後打印出來。
這個範例展示了如何使用 C# 的二維陣列來處理股票價格數據，並計算平均值，這在證券業界是非常常見的應用。
# 類別 (Class) 和物件 (Object) 及其應用
在這裡，將詳細說明 C# 中的類別和物件，並舉出一個證券業界常見的例子來說明如何使用類別和物件。
## 基本概念
### 類別 (Class)
類別是一種藍圖或模板，用於創建物件。它定義了一組屬性（變數）和方法（函式），這些屬性和方法是物件的特徵和行為。
例如，我們可以定義一個 `Stock` 類別，來表示一支股票的各種屬性和行為：
```csharp
public class Stock
{
// 屬性（變數）
public string Name { get; set; }
public double Price { get; set; }
public string Symbol { get; set; }
// 方法（函式）
public void DisplayInfo()
{
Console.WriteLine($"股票名稱: {Name}, 股票代號: {Symbol}, 股票價格: {Price}");
}
}
```
### 物件 (Object)
物件是類別的實例，通過類別創建物件後，我們可以操作這些物件。例如：
```csharp
Stock myStock = new Stock();
myStock.Name = "Apple Inc.";
myStock.Price = 150.25;
myStock.Symbol = "AAPL";
myStock.DisplayInfo();
```
在這個例子中，我們創建了一個 `Stock` 類別的物件 `myStock`，並設置其屬性，最後調用其方法來顯示資訊。
## 應用在證券業界的範例
假設我們要設計一個程式來管理多支股票的信息，並計算某支股票的價格變動，我們可以使用類別和物件來實現。
## 範例：股票管理系統
### 定義 `Stock` 類別
```csharp
public class Stock
{
public string Name { get; set; }
public double CurrentPrice { get; set; }
public double PreviousPrice { get; set; }
public string Symbol { get; set; }
// 計算價格變動的方法
public double GetPriceChange()
{
return CurrentPrice - PreviousPrice;
}
// 顯示股票信息的方法
public void DisplayInfo()
{
Console.WriteLine($"股票名稱: {Name}, 股票代號: {Symbol}, 當前價格: {CurrentPrice}, 之前價格: {PreviousPrice}");
}
}
```
### 使用 `Stock` 類別
```csharp
using System;
class Program
{
static void Main()
{
// 創建一個股票的物件
Stock stock1 = new Stock();
stock1.Name = "Apple Inc.";
stock1.CurrentPrice = 150.25;
stock1.PreviousPrice = 145.00;
stock1.Symbol = "AAPL";
// 顯示股票信息
stock1.DisplayInfo();
// 計算並顯示價格變動
double priceChange = stock1.GetPriceChange();
Console.WriteLine($"價格變動: {priceChange}");
// 創建另一個股票的物件
Stock stock2 = new Stock();
stock2.Name = "Microsoft Corporation";
stock2.CurrentPrice = 250.75;
stock2.PreviousPrice = 240.50;
stock2.Symbol = "MSFT";
// 顯示股票信息
stock2.DisplayInfo();
// 計算並顯示價格變動
double priceChange2 = stock2.GetPriceChange();
Console.WriteLine($"價格變動: {priceChange2}");
}
}
```
## 說明
1. **定義 `Stock` 類別**：
- `Stock` 類別包含股票的屬性（如 `Name`、`CurrentPrice`、`PreviousPrice` 和 `Symbol`）以及方法（如 `GetPriceChange` 和 `DisplayInfo`）。
- `GetPriceChange` 方法用於計算當前價格與之前價格之間的差異。
- `DisplayInfo` 方法用於顯示股票的基本信息。
2. **創建並使用物件**：
- 我們創建了兩個 `Stock` 類別的物件 `stock1` 和 `stock2`，並設置其屬性。
- 使用 `DisplayInfo` 方法來顯示每支股票的基本信息。
- 使用 `GetPriceChange` 方法來計算並顯示價格變動。
## 延伸與更優化
我們可以進一步優化這個程式，讓它能夠管理多支股票，並提供更多的功能，如添加、移除和查找股票。
### 增加股票管理功能
```csharp
using System;
using System.Collections.Generic;
public class Stock
{
public string Name { get; set; }
public double CurrentPrice { get; set; }
public double PreviousPrice { get; set; }
public string Symbol { get; set; }
public double GetPriceChange()
{
return CurrentPrice - PreviousPrice;
}
public void DisplayInfo()
{
Console.WriteLine($"股票名稱: {Name}, 股票代號: {Symbol}, 當前價格: {CurrentPrice}, 之前價格: {PreviousPrice}");
}
}
public class StockManager
{
private List<Stock> stocks = new List<Stock>();
public void AddStock(Stock stock)
{
stocks.Add(stock);
Console.WriteLine($"已添加股票: {stock.Name}");
}
public void RemoveStock(string symbol)
{
stocks.RemoveAll(s => s.Symbol == symbol);
Console.WriteLine($"已移除股票代號: {symbol}");
}
public Stock FindStock(string symbol)
{
return stocks.Find(s => s.Symbol == symbol);
}
public void DisplayAllStocks()
{
foreach (var stock in stocks)
{
stock.DisplayInfo();
}
}
}
class Program
{
static void Main()
{
StockManager manager = new StockManager();
Stock stock1 = new Stock
{
Name = "Apple Inc.",
CurrentPrice = 150.25,
PreviousPrice = 145.00,
Symbol = "AAPL"
};
manager.AddStock(stock1);
Stock stock2 = new Stock
{
Name = "Microsoft Corporation",
CurrentPrice = 250.75,
PreviousPrice = 240.50,
Symbol = "MSFT"
};
manager.AddStock(stock2);
Console.WriteLine("\n所有股票信息：");
manager.DisplayAllStocks();
Console.WriteLine("\n查找股票 MSFT 的信息：");
Stock foundStock = manager.FindStock("MSFT");
if (foundStock != null)
{
foundStock.DisplayInfo();
}
else
{
Console.WriteLine("找不到該股票");
}
manager.RemoveStock("AAPL");
Console.WriteLine("\n所有股票信息：");
manager.DisplayAllStocks();
}
}
```
## 說明
1. **股票管理類別 `StockManager`**：
- 我們創建了一個 `StockManager` 類別，用於管理多支股票，包含 `AddStock`、`RemoveStock`、`FindStock` 和 `DisplayAllStocks` 方法。
- `AddStock` 方法用於添加新股票。
- `RemoveStock` 方法用於移除股票。
- `FindStock` 方法用於查找特定股票。
- `DisplayAllStocks` 方法用於顯示所有股票的信息。
2. **管理多支股票**：
- 我們創建了一個 `StockManager` 物件 `manager`，並使用它來添加、查找和移除股票，最後顯示所有股票的信息。
這個範例展示了如何使用 C# 的類別和物件來管理股票信息，這在證券業界是非常常見的應用。
# Namespace 和 Using
在 C# 中，`namespace` 和 `using` 是兩個非常重要的概念，特別是在大型專案中，它們有助於組織代碼並提高可讀性和可維護性。下面，我們將詳細說明這兩個概念，並舉出一個證券業界常見的例子來說明如何使用它們。
## Namespace（命名空間）
### 基本概念
`namespace`（命名空間）是一種用來組織代碼的方式，它可以將相關的類別、介面、結構和枚舉放在一起，從而避免命名衝突。
例如，我們可以創建一個命名空間來包含所有與股票相關的類別：
```csharp
namespace StockManagement
{
public class Stock
{
public string Name { get; set; }
public double CurrentPrice { get; set; }
public double PreviousPrice { get; set; }
public string Symbol { get; set; }
public double GetPriceChange()
{
return CurrentPrice - PreviousPrice;
}
public void DisplayInfo()
{
Console.WriteLine($"股票名稱: {Name}, 股票代號: {Symbol}, 當前價格: {CurrentPrice}, 之前價格: {PreviousPrice}");
}
}
}
```
這樣，所有與股票相關的類別都可以放在 `StockManagement` 命名空間中。
## Using（引用）
### 基本概念
`using` 指令允許我們在代碼中使用其他命名空間中的類別和其他類型，而不必每次都指定完整的命名空間。
例如，如果我們在不同的命名空間中有一個 `StockManager` 類別，我們可以使用 `using` 指令來引用這個命名空間：
```csharp
using StockManagement;
public class StockManager
{
private List<Stock> stocks = new List<Stock>();
public void AddStock(Stock stock)
{
stocks.Add(stock);
Console.WriteLine($"已添加股票: {stock.Name}");
}
public void RemoveStock(string symbol)
{
stocks.RemoveAll(s => s.Symbol == symbol);
Console.WriteLine($"已移除股票代號: {symbol}");
}
public Stock FindStock(string symbol)
{
return stocks.Find(s => s.Symbol == symbol);
}
public void DisplayAllStocks()
{
foreach (var stock in stocks)
{
stock.DisplayInfo();
}
}
}
```
在這個例子中，我們使用 `using StockManagement;` 指令來引用 `StockManagement` 命名空間，這樣我們就可以直接使用 `Stock` 類別，而不需要每次都寫 `StockManagement.Stock`。
## 應用在證券業界的範例
假設我們要設計一個程式來管理多支股票的信息，並顯示每支股票的價格變動，我們可以使用命名空間和引用來組織代碼。
## 範例：股票管理系統
### 定義命名空間和類別
```csharp
// StockManagement 命名空間
namespace StockManagement
{
public class Stock
{
public string Name { get; set; }
public double CurrentPrice { get; set; }
public double PreviousPrice { get; set; }
public string Symbol { get; set; }
public double GetPriceChange()
{
return CurrentPrice - PreviousPrice;
}
public void DisplayInfo()
{
Console.WriteLine($"股票名稱: {Name}, 股票代號: {Symbol}, 當前價格: {CurrentPrice}, 之前價格: {PreviousPrice}");
}
}
}
// StockManagementManager 命名空間
namespace StockManagementManager
{
using StockManagement;
using System.Collections.Generic;
public class StockManager
{
private List<Stock> stocks = new List<Stock>();
public void AddStock(Stock stock)
{
stocks.Add(stock);
Console.WriteLine($"已添加股票: {stock.Name}");
}
public void RemoveStock(string symbol)
{
stocks.RemoveAll(s => s.Symbol == symbol);
Console.WriteLine($"已移除股票代號: {symbol}");
}
public Stock FindStock(string symbol)
{
return stocks.Find(s => s.Symbol == symbol);
}
public void DisplayAllStocks()
{
foreach (var stock in stocks)
{
stock.DisplayInfo();
}
}
}
}
```
### 使用命名空間和類別
```csharp
using System;
using StockManagement;
using StockManagementManager;
class Program
{
static void Main()
{
StockManager manager = new StockManager();
Stock stock1 = new Stock
{
Name = "Apple Inc.",
CurrentPrice = 150.25,
PreviousPrice = 145.00,
Symbol = "AAPL"
};
manager.AddStock(stock1);
Stock stock2 = new Stock
{
Name = "Microsoft Corporation",
CurrentPrice = 250.75,
PreviousPrice = 240.50,
Symbol = "MSFT"
};
manager.AddStock(stock2);
Console.WriteLine("\n所有股票信息：");
manager.DisplayAllStocks();
Console.WriteLine("\n查找股票 MSFT 的信息：");
Stock foundStock = manager.FindStock("MSFT");
if (foundStock != null)
{
foundStock.DisplayInfo();
}
else
{
Console.WriteLine("找不到該股票");
}
manager.RemoveStock("AAPL");
Console.WriteLine("\n所有股票信息：");
manager.DisplayAllStocks();
}
}
```
## 說明
1. **命名空間 `StockManagement` 和 `StockManagementManager`**：
- `StockManagement` 命名空間包含 `Stock` 類別。
- `StockManagementManager` 命名空間包含 `StockManager` 類別，並引用了 `StockManagement` 命名空間。
2. **引用命名空間**：
- 在 `StockManagementManager` 命名空間中，我們使用 `using StockManagement;` 指令來引用 `StockManagement` 命名空間，以便可以直接使用 `Stock` 類別。
- 在主程式中，我們使用 `using StockManagement;` 和 `using StockManagementManager;` 指令來引用這兩個命名空間，這樣可以直接使用 `Stock` 和 `StockManager` 類別。
3. **管理多支股票**：
- 我們創建了一個 `StockManager` 物件 `manager`，並使用它來添加、查找和移除股票，最後顯示所有股票的信息。
這個範例展示了如何使用 C# 的命名空間和引用來組織和管理代碼，這在證券業界的應用中是非常有用的，特別是在處理大量和多樣化的股票信息時。
# method 方法
在 C# 中，**方法（Method）** 是用來執行特定任務的一段代碼。方法可以接收輸入（參數）、執行操作，然後返回輸出（回傳值）。方法讓我們可以將重複使用的邏輯集中在一個地方，使程式碼更清晰、更易於維護。
## 方法的基本結構
一個方法的基本結構如下：
```csharp
public 返回類型 方法名稱(參數類型 參數名稱)
{
// 方法的主體
// 執行某些操作
return 返回值;
}
```
## 方法的範例
假設我們在證券界的應用程式中需要一個方法來計算股票的價格變動，我們可以這樣定義一個方法：
```csharp
public double CalculatePriceChange(double currentPrice, double previousPrice)
{
return currentPrice - previousPrice;
}
```
這個方法接收當前價格和之前價格，然後返回它們之間的差值。
## 應用在證券界的範例
我們將使用方法來處理股票的相關操作，比如計算價格變動、顯示股票信息等。
### 定義類別和方法
```csharp
using System;
namespace StockManagement
{
public class Stock
{
public string Name { get; set; }
public double CurrentPrice { get; set; }
public double PreviousPrice { get; set; }
public string Symbol { get; set; }
// 計算價格變動的方法
public double CalculatePriceChange()
{
return CurrentPrice - PreviousPrice;
}
// 顯示股票信息的方法
public void DisplayInfo()
{
Console.WriteLine($"股票名稱: {Name}, 股票代號: {Symbol}, 當前價格: {CurrentPrice}, 之前價格: {PreviousPrice}");
Console.WriteLine($"價格變動: {CalculatePriceChange()}");
}
}
}
namespace StockManagementManager
{
using StockManagement;
using System.Collections.Generic;
public class StockManager
{
private List<Stock> stocks = new List<Stock>();
public void AddStock(Stock stock)
{
stocks.Add(stock);
Console.WriteLine($"已添加股票: {stock.Name}");
}
public void RemoveStock(string symbol)
{
stocks.RemoveAll(s => s.Symbol == symbol);
Console.WriteLine($"已移除股票代號: {symbol}");
}
public Stock FindStock(string symbol)
{
return stocks.Find(s => s.Symbol == symbol);
}
public void DisplayAllStocks()
{
foreach (var stock in stocks)
{
stock.DisplayInfo();
}
}
}
}
```
### 使用方法的範例
```csharp
using System;
using StockManagement;
using StockManagementManager;
class Program
{
static void Main()
{
StockManager manager = new StockManager();
Stock stock1 = new Stock
{
Name = "Apple Inc.",
CurrentPrice = 150.25,
PreviousPrice = 145.00,
Symbol = "AAPL"
};
manager.AddStock(stock1);
Stock stock2 = new Stock
{
Name = "Microsoft Corporation",
CurrentPrice = 250.75,
PreviousPrice = 240.50,
Symbol = "MSFT"
};
manager.AddStock(stock2);
Console.WriteLine("\n所有股票信息：");
manager.DisplayAllStocks();
Console.WriteLine("\n查找股票 MSFT 的信息：");
Stock foundStock = manager.FindStock("MSFT");
if (foundStock != null)
{
foundStock.DisplayInfo();
}
else
{
Console.WriteLine("找不到該股票");
}
manager.RemoveStock("AAPL");
Console.WriteLine("\n所有股票信息：");
manager.DisplayAllStocks();
}
}
```
## 說明
1. **定義方法**：
- 在 `Stock` 類別中，我們定義了兩個方法：`CalculatePriceChange` 和 `DisplayInfo`。
- `CalculatePriceChange` 方法用於計算當前價格和之前價格之間的差值。
- `DisplayInfo` 方法用於顯示股票的詳細信息，包括名稱、代號、當前價格、之前價格以及價格變動。
2. **使用方法**：
- 在主程式中，我們創建了幾支股票並使用 `AddStock` 方法將它們添加到 `StockManager` 中。
- 使用 `DisplayAllStocks` 方法顯示所有股票的信息。
- 使用 `FindStock` 方法查找特定代號的股票，並使用 `DisplayInfo` 方法顯示該股票的信息。
- 使用 `RemoveStock` 方法移除特定代號的股票，然後再次顯示所有股票的信息。
## 總結
通過這個例子，我們展示了如何在 C# 中定義和使用方法來執行特定任務，並且如何將這些方法應用於證券界的常見操作。方法讓代碼更具結構性和可重用性，這在開發和維護程式時非常重要。
# Main 方法
在 C# 中，**`Main` 方法** 是應用程式的入口點。每當你執行一個 C# 應用程式時，`Main` 方法是最先被呼叫的方法。它告訴電腦從哪裡開始執行程式碼。`Main` 方法通常位於程式的最外層類別中，並且只能有一個 `Main` 方法。
## `Main` 方法的基本結構
一個基本的 `Main` 方法結構如下：
```csharp
using System;
class Program
{
static void Main(string[] args)
{
// 程式碼從這裡開始執行
Console.WriteLine("Hello, World!");
}
}
```
## `Main` 方法的特點
1. **`Main` 方法必須是靜態的**：這意味著你可以直接呼叫它，而不需要先創建類的實例。
2. **可以有回傳類型或無回傳類型**：`Main` 方法可以回傳 `void` 或 `int`。回傳 `int` 的方法通常用於返回狀態碼給作業系統。
3. **可以接收參數**：參數是命令列引數，通常以字串陣列 (`string[] args`) 的形式傳遞。
## 應用在證券界的範例
假設我們有一個簡單的證券應用程式，它可以讓用戶輸入股票名稱和當前價格，並計算價格變動。我們可以這樣設計 `Main` 方法：
### 定義類別和方法
首先，定義一個 `Stock` 類別，包含一些基本的屬性和方法：
```csharp
using System;
namespace StockManagement
{
public class Stock
{
public string Name { get; set; }
public double CurrentPrice { get; set; }
public double PreviousPrice { get; set; }
public double CalculatePriceChange()
{
return CurrentPrice - PreviousPrice;
}
public void DisplayInfo()
{
Console.WriteLine($"股票名稱: {Name}");
Console.WriteLine($"當前價格: {CurrentPrice}");
Console.WriteLine($"之前價格: {PreviousPrice}");
Console.WriteLine($"價格變動: {CalculatePriceChange()}");
}
}
}
```
### 主程式的 `Main` 方法
接著，定義 `Main` 方法，讓用戶輸入股票資料並顯示結果：
```csharp
using System;
using StockManagement;
class Program
{
static void Main(string[] args)
{
// 創建新的股票實例
Stock stock = new Stock();
// 要求用戶輸入股票名稱
Console.Write("請輸入股票名稱: ");
stock.Name = Console.ReadLine();
// 要求用戶輸入當前價格
Console.Write("請輸入當前價格: ");
stock.CurrentPrice = Convert.ToDouble(Console.ReadLine());
// 要求用戶輸入之前價格
Console.Write("請輸入之前價格: ");
stock.PreviousPrice = Convert.ToDouble(Console.ReadLine());
// 顯示股票信息
stock.DisplayInfo();
// 暫停程式，等待用戶按下任意鍵繼續
Console.WriteLine("按下任意鍵結束...");
Console.ReadKey();
}
}
```
## 說明
1. **創建 `Stock` 類別**：
- `Stock` 類別包含股票的基本資料：名稱、當前價格和之前價格。
- `CalculatePriceChange` 方法計算當前價格和之前價格之間的變動。
- `DisplayInfo` 方法顯示股票的詳細資訊。
2. **在 `Main` 方法中使用 `Stock` 類別**：
- `Main` 方法讓用戶輸入股票的名稱、當前價格和之前價格。
- 使用 `Console.ReadLine()` 方法從用戶那裡獲取輸入。
- 使用 `Convert.ToDouble()` 方法將輸入的字串轉換成雙精度浮點數。
- 呼叫 `DisplayInfo` 方法顯示股票的所有信息，包括價格變動。
## 總結
這個範例展示了如何使用 `Main` 方法作為應用程式的入口點，並結合了 C# 的基本概念，如類別、方法和用戶輸入。通過這個例子，不懂程式的人可以理解 `Main` 方法的重要性及其在一個簡單的證券應用程式中的應用。
# Constructor（建構方法）
在 C# 中，**Constructor（建構方法）** 是一種特殊的方法，當你創建一個類的新實例時，它會自動被呼叫。建構方法主要用來初始化物件的狀態，例如設置物件的初始值。
## Constructor 的基本結構
```csharp
class 類別名稱
{
// 建構方法
public 類別名稱()
{
// 初始化代碼
}
}
```
建構方法的名稱必須與類別名稱相同，並且不返回任何值（甚至不返回 `void`）。
## Constructor 的範例
假設我們在證券界的應用程式中需要一個類來表示股票，我們可以這樣定義建構方法：
```csharp
using System;
namespace StockManagement
{
public class Stock
{
// 屬性
public string Name { get; set; }
public double CurrentPrice { get; set; }
public double PreviousPrice { get; set; }
// 建構方法
public Stock(string name, double currentPrice, double previousPrice)
{
Name = name;
CurrentPrice = currentPrice;
PreviousPrice = previousPrice;
}
// 方法：計算價格變動
public double CalculatePriceChange()
{
return CurrentPrice - PreviousPrice;
}
// 方法：顯示股票信息
public void DisplayInfo()
{
Console.WriteLine($"股票名稱: {Name}");
Console.WriteLine($"當前價格: {CurrentPrice}");
Console.WriteLine($"之前價格: {PreviousPrice}");
Console.WriteLine($"價格變動: {CalculatePriceChange()}");
}
}
}
```
## 應用在證券界的範例
假設我們需要創建一個簡單的證券應用程式來管理股票，我們可以利用建構方法來初始化每個股票物件。
### 主程式使用建構方法
```csharp
using System;
using StockManagement;
class Program
{
static void Main(string[] args)
{
// 使用建構方法創建新的股票實例
Stock stock1 = new Stock("Apple Inc.", 150.25, 145.00);
Stock stock2 = new Stock("Microsoft Corporation", 250.75, 240.50);
// 顯示股票信息
stock1.DisplayInfo();
Console.WriteLine(); // 空行
stock2.DisplayInfo();
// 暫停程式，等待用戶按下任意鍵繼續
Console.WriteLine("按下任意鍵結束...");
Console.ReadKey();
}
}
```
## 說明
1. **定義 `Stock` 類別**：
- `Stock` 類別包含三個屬性：`Name`、`CurrentPrice` 和 `PreviousPrice`。
- `Stock` 類別有一個建構方法，接受三個參數來初始化這些屬性。
2. **在 `Main` 方法中使用建構方法**：
- 我們使用建構方法創建了兩個 `Stock` 類別的新實例：`stock1` 和 `stock2`。
- 在創建這些實例時，我們同時傳遞了股票名稱、當前價格和之前價格作為參數。
- 使用 `DisplayInfo` 方法顯示每個股票的詳細信息。
## 總結
通過這個例子，我們展示了如何使用 C# 的建構方法來初始化物件，並應用在證券界常見的股票管理應用程式中。建構方法讓我們可以在創建物件時設置其初始狀態，從而使得代碼更加清晰和可維護。這樣，不懂程式的人也能理解建構方法的重要性及其應用。
### Getter 和 Setter
在 C# 中，**getter** 和 **setter** 是屬性（Property）的一部分，用來控制對類別中成員變數的訪問和修改。它們提供了一種安全且簡潔的方法來讀取和設置物件的屬性。
## Getter 和 Setter 的基本結構
```csharp
public class 類別名稱
{
// 成員變數
private 類型 變數名稱;
// 屬性
public 類型 屬性名稱
{
get { return 變數名稱; }
set { 變數名稱 = value; }
}
}
```
- **Getter**：用來取得屬性的值。
- **Setter**：用來設定屬性的值。
## Getter 和 Setter 的範例
假設我們在證券界的應用程式中需要一個類來表示股票，我們可以這樣定義 getter 和 setter：
```csharp
using System;
namespace StockManagement
{
public class Stock
{
// 成員變數
private string name;
private double currentPrice;
private double previousPrice;
// 屬性
public string Name
{
get { return name; }
set { name = value; }
}
public double CurrentPrice
{
get { return currentPrice; }
set { currentPrice = value; }
}
public double PreviousPrice
{
get { return previousPrice; }
set { previousPrice = value; }
}
// 方法：計算價格變動
public double CalculatePriceChange()
{
return currentPrice - previousPrice;
}
// 方法：顯示股票信息
public void DisplayInfo()
{
Console.WriteLine($"股票名稱: {Name}");
Console.WriteLine($"當前價格: {CurrentPrice}");
Console.WriteLine($"之前價格: {PreviousPrice}");
Console.WriteLine($"價格變動: {CalculatePriceChange()}");
}
}
}
```
## 應用在證券界的範例
假設我們需要創建一個簡單的證券應用程式來管理股票，我們可以利用 getter 和 setter 來讀取和設置股票屬性。
### 主程式使用 getter 和 setter
```csharp
using System;
using StockManagement;
class Program
{
static void Main(string[] args)
{
// 創建新的股票實例
Stock stock1 = new Stock();
// 設置股票屬性
stock1.Name = "台積電";
stock1.CurrentPrice = 600.50;
stock1.PreviousPrice = 580.00;
// 顯示股票信息
stock1.DisplayInfo();
// 使用 getter 取得屬性值
Console.WriteLine($"股票 {stock1.Name} 的當前價格是 {stock1.CurrentPrice}");
// 暫停程式，等待用戶按下任意鍵繼續
Console.WriteLine("按下任意鍵結束...");
Console.ReadKey();
}
}
```
## 說明
1. **定義 `Stock` 類別**：
- `Stock` 類別包含三個成員變數：`name`、`currentPrice` 和 `previousPrice`。
- 使用屬性 `Name`、`CurrentPrice` 和 `PreviousPrice`，分別提供 getter 和 setter，用來訪問和修改成員變數的值。
2. **在 `Main` 方法中使用 getter 和 setter**：
- 創建 `Stock` 類別的新實例 `stock1`。
- 使用 setter 設置股票的名稱、當前價格和之前價格。
- 呼叫 `DisplayInfo` 方法顯示股票的所有信息。
- 使用 getter 取得 `stock1` 的名稱和當前價格，並顯示在控制台上。
## 總結
這個範例展示了如何使用 C# 的 getter 和 setter 來控制類別中成員變數的訪問和修改，並應用在證券界常見的股票管理應用程式中。通過使用 getter 和 setter，我們可以更加安全和靈活地操作物件的屬性，從而使得代碼更加清晰和可維護。這樣，不懂程式的人也能理解 getter 和 setter 的重要性及其應用。
# Static Attribute（靜態屬性）
在 C# 中，**靜態屬性**（static attribute）是屬於類別本身的屬性，而不是某個特定物件的屬性。這意味著靜態屬性在所有物件之間是共享的，無需創建物件實例就可以訪問它。
## 靜態屬性的基本結構
```csharp
public class 類別名稱
{
// 靜態屬性
public static 類型 屬性名稱 { get; set; }
}
```
- **static** 關鍵字用來聲明靜態屬性。
- 靜態屬性可以直接通過類別名稱訪問，而不需要創建類別的實例。
## 靜態屬性的範例
假設我們在證券界的應用程式中需要一個類來表示股票市場的交易狀態，我們可以這樣定義靜態屬性：
```csharp
using System;
namespace StockManagement
{
public class StockMarket
{
// 靜態屬性
public static string MarketStatus { get; set; } = "Closed";
// 方法：顯示市場狀態
public static void DisplayMarketStatus()
{
Console.WriteLine($"市場狀態: {MarketStatus}");
}
}
}
```
## 應用在證券界的範例
假設我們需要創建一個簡單的證券應用程式來管理股票市場的交易狀態，我們可以利用靜態屬性來保存和訪問市場的當前狀態。
### 主程式使用靜態屬性
```csharp
using System;
using StockManagement;
class Program
{
static void Main(string[] args)
{
// 顯示初始市場狀態
StockMarket.DisplayMarketStatus();
// 設置市場狀態
StockMarket.MarketStatus = "Open";
Console.WriteLine("市場已開放");
// 顯示更新後的市場狀態
StockMarket.DisplayMarketStatus();
// 設置市場狀態為中斷
StockMarket.MarketStatus = "Halted";
Console.WriteLine("市場已中斷");
// 顯示更新後的市場狀態
StockMarket.DisplayMarketStatus();
// 暫停程式，等待用戶按下任意鍵繼續
Console.WriteLine("按下任意鍵結束...");
Console.ReadKey();
}
}
```
## 說明
1. **定義 `StockMarket` 類別**：
- `StockMarket` 類別包含一個靜態屬性 `MarketStatus`，用來表示市場的交易狀態。初始值為 "Closed"。
- 使用靜態方法 `DisplayMarketStatus` 來顯示當前的市場狀態。
2. **在 `Main` 方法中使用靜態屬性**：
- 我們直接通過 `StockMarket` 類別訪問和修改靜態屬性 `MarketStatus`。
- 程式首先顯示初始市場狀態，然後將市場狀態設置為 "Open" 並顯示更新後的狀態，最後將市場狀態設置為 "Halted" 並顯示更新後的狀態。
## 總結
這個範例展示了如何使用 C# 的靜態屬性來表示和管理股票市場的交易狀態，並應用在證券界常見的情境中。靜態屬性屬於類別本身，無需創建物件實例就可以訪問，並在所有物件之間共享。這樣，不懂程式的人也能理解靜態屬性的基本概念及其應用。
# Static Method 和 Static Class
在 C# 中，**靜態方法**（static method）和 **靜態類別**（static class）是用來表示屬於類別本身的成員，而不是某個特定物件的成員。靜態成員可以直接通過類別名稱訪問，而不需要創建類別的實例。
## 靜態方法（Static Method）
靜態方法是屬於類別本身的方法，可以直接通過類別名稱調用。靜態方法不能訪問非靜態成員，因為它們沒有物件實例來參考。
### 靜態方法的基本結構
```csharp
public class 類別名稱
{
public static 返回類型 方法名稱(參數)
{
// 方法內容
}
}
```
## 靜態類別（Static Class）
靜態類別是一種特殊的類別，所有成員都必須是靜態的。靜態類別不能被實例化，不能包含實例建構方法。
### 靜態類別的基本結構
```csharp
public static class 類別名稱
{
public static 返回類型 方法名稱(參數)
{
// 方法內容
}
}
```
## 靜態方法和靜態類別的範例
假設我們在證券界的應用程式中需要一些通用的方法來計算股票相關的數據，我們可以使用靜態方法和靜態類別來實現這些功能。
### 靜態類別和方法的範例
```csharp
using System;
namespace StockManagement
{
// 靜態類別
public static class StockUtilities
{
// 靜態方法：計算股票價格變動百分比
public static double CalculatePriceChangePercentage(double oldPrice, double newPrice)
{
if (oldPrice == 0)
throw new ArgumentException("Old price cannot be zero.");
return ((newPrice - oldPrice) / oldPrice) * 100;
}
// 靜態方法：格式化價格
public static string FormatPrice(double price)
{
return price.ToString("C");
}
}
}
```
## 應用在證券界的範例
假設我們需要創建一個簡單的證券應用程式來計算和顯示股票的價格變動百分比和格式化後的價格，我們可以利用靜態方法和靜態類別來實現這些功能。
### 主程式使用靜態方法和靜態類別
```csharp
using System;
using StockManagement;
class Program
{
static void Main(string[] args)
{
// 設定舊價格和新價格
double oldPrice = 500.00;
double newPrice = 550.00;
// 使用靜態方法計算價格變動百分比
double changePercentage = StockUtilities.CalculatePriceChangePercentage(oldPrice, newPrice);
Console.WriteLine($"股票價格變動百分比: {changePercentage}%");
// 使用靜態方法格式化價格
string formattedOldPrice = StockUtilities.FormatPrice(oldPrice);
string formattedNewPrice = StockUtilities.FormatPrice(newPrice);
Console.WriteLine($"舊價格: {formattedOldPrice}");
Console.WriteLine($"新價格: {formattedNewPrice}");
// 暫停程式，等待用戶按下任意鍵繼續
Console.WriteLine("按下任意鍵結束...");
Console.ReadKey();
}
}
```
## 說明
1. **定義 `StockUtilities` 靜態類別**：
- `StockUtilities` 是一個靜態類別，包含兩個靜態方法。
- `CalculatePriceChangePercentage` 方法用來計算股票價格變動的百分比。
- `FormatPrice` 方法用來將價格格式化為貨幣格式。
2. **在 `Main` 方法中使用靜態方法和靜態類別**：
- 我們直接通過 `StockUtilities` 類別訪問靜態方法 `CalculatePriceChangePercentage` 和 `FormatPrice`。
- 程式首先設定股票的舊價格和新價格，然後使用靜態方法計算價格變動百分比並顯示。
- 接著使用靜態方法格式化價格並顯示。
## 總結
這個範例展示了如何使用 C# 的靜態方法和靜態類別來實現股票價格相關的計算和格式化功能，並應用在台灣證券界常見的情境中。靜態方法和靜態類別提供了一種方便的方法來組織和共享通用功能，無需創建物件實例即可使用，從而使得代碼更加簡潔和易於維護。這樣，不懂程式的人也能理解靜態方法和靜態類別的基本概念及其應用。
# 繼承（Inheritance）
在 C# 中，**繼承**（inheritance）是一種物件導向程式設計的概念，允許我們創建一個新的類別，這個新類別可以繼承另一個現有類別的屬性和方法。繼承可以幫助我們重用程式碼，並且可以讓程式碼更加結構化和容易維護。
## 繼承的基本結構
```csharp
public class 基類
{
// 基類的屬性和方法
}
public class 派生類 : 基類
{
// 派生類的額外屬性和方法
}
```
- **基類**（Base Class）：也稱為父類或超類，是被繼承的類別。
- **派生類**（Derived Class）：也稱為子類，是繼承基類的類別。
## 繼承的範例
假設我們在證券界的應用程式中需要管理不同種類的證券（例如股票和債券），我們可以創建一個通用的基類來表示所有證券，然後創建派生類來表示具體的股票和債券。
### 定義基類和派生類
```csharp
using System;
namespace StockManagement
{
// 基類：證券
public class Security
{
public string TickerSymbol { get; set; }
public double Price { get; set; }
public void DisplayInfo()
{
Console.WriteLine($"代碼: {TickerSymbol}, 價格: {Price}");
}
}
// 派生類：股票
public class Stock : Security
{
public string Exchange { get; set; }
public void DisplayStockInfo()
{
DisplayInfo();
Console.WriteLine($"交易所: {Exchange}");
}
}
// 派生類：債券
public class Bond : Security
{
public double InterestRate { get; set; }
public void DisplayBondInfo()
{
DisplayInfo();
Console.WriteLine($"利率: {InterestRate}%");
}
}
}
```
## 應用在證券界的範例
假設我們需要創建一個簡單的證券應用程式來管理和顯示不同種類的證券（股票和債券），我們可以利用繼承來實現這些功能。
### 主程式使用基類和派生類
```csharp
using System;
using StockManagement;
class Program
{
static void Main(string[] args)
{
// 創建股票對象
Stock stock = new Stock
{
TickerSymbol = "2330.TW",
Price = 600.00,
Exchange = "台灣證券交易所"
};
// 創建債券對象
Bond bond = new Bond
{
TickerSymbol = "TW10Y",
Price = 1000.00,
InterestRate = 0.75
};
// 顯示股票信息
Console.WriteLine("股票信息:");
stock.DisplayStockInfo();
// 顯示債券信息
Console.WriteLine("\n債券信息:");
bond.DisplayBondInfo();
// 暫停程式，等待用戶按下任意鍵繼續
Console.WriteLine("\n按下任意鍵結束...");
Console.ReadKey();
}
}
```
## 說明
1. **定義 `Security` 基類**：
- `Security` 基類包含通用的屬性 `TickerSymbol` 和 `Price`，以及一個方法 `DisplayInfo` 來顯示證券的基本信息。
2. **定義 `Stock` 和 `Bond` 派生類**：
- `Stock` 類繼承自 `Security`，並添加了額外的屬性 `Exchange` 和方法 `DisplayStockInfo`。
- `Bond` 類繼承自 `Security`，並添加了額外的屬性 `InterestRate` 和方法 `DisplayBondInfo`。
3. **在 `Main` 方法中使用基類和派生類**：
- 我們創建了 `Stock` 和 `Bond` 的物件，並設置它們的屬性。
- 然後，我們使用各自的顯示方法來顯示股票和債券的信息。
## 總結
這個範例展示了如何使用 C# 的繼承來重用和擴展基類的功能，以管理不同種類的證券（例如股票和債券），並應用在證券界常見的情境中。繼承允許我們創建具有通用屬性和方法的基類，並在派生類中添加特定的屬性和方法，使得程式碼更加結構化和易於維護。這樣，不懂程式的人也能理解繼承的基本概念及其應用。
Sign in with Wallet
Connect another wallet