Menu
CoddyTech

Variabel Lingkungan

Termasuk bagian Dasar-Dasar C# dan .NET dalam perjalanan ASP.NET Core di Coddy. Pelajaran 20 dari 20.

Variabel lingkungan adalah nilai teks bernama yang diberikan shell atau server kepada setiap program yang dijalankannya. Pengaturan yang berbeda dari satu komputer ke komputer lain disimpan di sana: lokasi file, alamat database, kunci rahasia. Environment.GetEnvironmentVariable(name) membaca satu variabel dan mengembalikan string?: null jika variabel itu belum diatur.

var name = Environment.GetEnvironmentVariable("GREETING_NAME") ?? "world";
Console.WriteLine($"Hello, {name}!");
Console.WriteLine(Environment.CurrentDirectory);

Di shell macOS atau Linux, GREETING_NAME=Ada dotnet run mengaturnya untuk satu kali menjalankan program dan mencetak Hello, Ada!; PowerShell menggunakan $env:GREETING_NAME = "Ada". Environment juga memiliki CurrentDirectory, NewLine, ProcessorCount dan Exit(code). ASP.NET Core juga membaca pengaturannya dari variabel lingkungan.

challenge icon

Tantangan

Mudah

Biarkan pengguna memilih file yang digunakan pelacak. Untuk pelajaran ini, tombol “Periksa” mengatur EXPENSES_FILE ke trip.json, file baru di proyekmu. Jalankan di terminal tidak mengaturnya.

  1. Ubah baris pertama setelah baris using agar file berisi nilai variabel lingkungan EXPENSES_FILE, atau "expenses.json" jika variabel tersebut tidak diatur.
  2. Setiap perintah sudah menggunakan file, jadi tidak ada hal lain yang berubah.

Dengan EXPENSES_FILE=trip.json, dotnet run mencetak:

Expense Tracker
2 expenses
Total: 253.50

dan add menyimpan ke trip.json, sementara expenses.json tetap seperti semula.

Coba: tekan Jalankan. Jalankan di terminal tidak mengatur variabel lingkungan, jadi EXPENSES_FILE bernilai null di sana dan pelacak menggunakan expenses.json: 3 expenses dan Total: 48.50, seperti sebelumnya. Itulah cara kerja ??. Tombol “Periksa” mengatur EXPENSES_FILE=trip.json dan mengharapkan tiga baris di atas.

Coba sendiri

using System.Globalization;
using System.Text.Json;

var file = "expenses.json";
var expenses = new List<Expense>();
if (File.Exists(file))
{
    expenses = JsonSerializer.Deserialize<List<Expense>>(File.ReadAllText(file)) ?? new List<Expense>();
}
var budgets = new Dictionary<string, decimal>();
if (File.Exists("budgets.json"))
{
    budgets = JsonSerializer.Deserialize<Dictionary<string, decimal>>(File.ReadAllText("budgets.json")) ?? new Dictionary<string, decimal>();
}
var count = expenses.Count;
var total = expenses.Sum(e => e.Amount);

if (args.Length == 0)
{
    Console.WriteLine("Expense Tracker");
    Console.WriteLine($"{count} expenses");
    Console.WriteLine($"Total: {total:F2}");
}
else
{
    switch (args[0])
    {
        case "add":
            if (args.Length < 3)
            {
                Console.Error.WriteLine("Usage: add <name> <amount> [category]");
                return 1;
            }
            if (!decimal.TryParse(args[2], CultureInfo.InvariantCulture, out var amount))
            {
                Console.Error.WriteLine($"Invalid amount: {args[2]}");
                return 1;
            }
            if (amount is <= 0 or > 10000)
            {
                Console.Error.WriteLine("The amount must be more than 0 and at most 10000.");
                return 1;
            }
            var category = args.Length > 3 ? args[3] : "other";
            var expense = new Expense(args[1], amount, category);
            expenses.Add(expense);
            File.WriteAllText(file, JsonSerializer.Serialize(expenses));
            Console.WriteLine($"Added {expense.Name}: {expense.Amount:F2} ({expense.Category})");
            if (budgets.TryGetValue(category, out var limit))
            {
                var spent = expenses.Where(e => e.Category == category).Sum(e => e.Amount);
                if (spent > limit)
                {
                    Console.WriteLine($"Over budget for {category}: {spent:F2} of {limit:F2}");
                }
            }
            break;
        case "remove":
            if (args.Length < 2)
            {
                Console.Error.WriteLine("Usage: remove <name>");
                return 1;
            }
            Expense? match = expenses.Find(e => e.Name == args[1]);
            if (match is null)
            {
                Console.Error.WriteLine($"No expense named {args[1]}.");
                return 1;
            }
            expenses.Remove(match);
            File.WriteAllText(file, JsonSerializer.Serialize(expenses));
            Console.WriteLine($"Removed {match.Name}: {match.Amount:F2}");
            break;
        case "list":
            var shown = args.Length > 1 ? expenses.Where(e => e.Category == args[1]).ToList() : expenses;
            if (shown.Count == 0)
            {
                Console.WriteLine("No expenses.");
                break;
            }
            foreach (var line in shown.Select(e => $"{e.Name}: {e.Amount:F2} ({e.Category})"))
            {
                Console.WriteLine(line);
            }
            break;
        case "top":
            var howMany = 3;
            if (args.Length > 1 && !int.TryParse(args[1], out howMany))
            {
                Console.Error.WriteLine($"Invalid number: {args[1]}");
                return 1;
            }
            var biggest = expenses.OrderByDescending(e => e.Amount).Take(howMany);
            foreach (var line in biggest.Select((e, i) => $"{i + 1}. {e.Name}: {e.Amount:F2} ({e.Category})"))
            {
                Console.WriteLine(line);
            }
            break;
        case "categories":
            var groups = expenses.GroupBy(e => e.Category).OrderByDescending(g => g.Sum(e => e.Amount));
            foreach (var g in groups)
            {
                Console.WriteLine($"{g.Key}: {g.Sum(e => e.Amount):F2} ({g.Count()})");
            }
            break;
        case "help":
            var topic = args.Length > 1 ? args[1] : "";
            var help = topic switch
            {
                "" => "Type help <command>, such as help add.",
                "add" => "add <name> <amount> [category]: saves an expense",
                "remove" => "remove <name>: deletes the first expense with that name",
                "list" => "list [category]: shows the saved expenses",
                "top" => "top [n]: shows the n biggest expenses, 3 by default",
                "categories" => "categories: shows the total of each category",
                "import" => "import <file>: adds the expenses in a CSV file",
                "export" => "export: writes every expense to exports/expenses.csv",
                _ => $"No help for {topic}.",
            };
            Console.WriteLine(help);
            break;
        case "import":
            if (args.Length < 2)
            {
                Console.Error.WriteLine("Usage: import <file>");
                return 1;
            }
            if (!File.Exists(args[1]))
            {
                Console.Error.WriteLine($"No file named {args[1]}.");
                return 1;
            }
            var imported = 0;
            var lineNumber = 0;
            foreach (var row in File.ReadAllLines(args[1]))
            {
                lineNumber++;
                try
                {
                    var parts = row.Split(',');
                    if (parts.Length != 3)
                    {
                        throw new FormatException("A line needs a name, an amount and a category.");
                    }
                    expenses.Add(new Expense(parts[0], decimal.Parse(parts[1], CultureInfo.InvariantCulture), parts[2]));
                    imported++;
                }
                catch (FormatException ex)
                {
                    Console.Error.WriteLine($"Line {lineNumber} skipped: {ex.Message}");
                }
            }
            File.WriteAllText(file, JsonSerializer.Serialize(expenses));
            Console.WriteLine($"Imported {imported} expenses from {args[1]}.");
            break;
        case "export":
            var folder = "exports";
            Directory.CreateDirectory(folder);
            var csvPath = Path.Combine(folder, "expenses.csv");
            File.WriteAllLines(csvPath, expenses.Select(e => $"{e.Name},{e.Amount.ToString("F2", CultureInfo.InvariantCulture)},{e.Category}"));
            Console.WriteLine($"Exported {expenses.Count} expenses to {csvPath}.");
            foreach (var g in expenses.GroupBy(e => e.Category))
            {
                var categoryPath = Path.Combine(folder, $"{g.Key}.csv");
                await File.WriteAllLinesAsync(categoryPath, g.Select(e => $"{e.Name},{e.Amount.ToString("F2", CultureInfo.InvariantCulture)},{e.Category}"));
                Console.WriteLine($"Wrote {categoryPath}");
            }
            break;
        default:
            Console.Error.WriteLine($"Unknown command: {args[0]}");
            return 1;
    }
}
return 0;

Semua pelajaran di Dasar-Dasar C# dan .NET