C#でのオフラインアプリケーション開発: 基礎から応用まで

int number = 10;
string message = "Hello, World!";

if (number > 5)
{
    Console.WriteLine("Number is greater than 5");
}
else
{
    Console.WriteLine("Number is 5 or less");
}

for (int i = 0; i < 5; i++)
{
    Console.WriteLine($"i = {i}");
}

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Hello, World!");
    }
}

using System.Data.SQLite;

// SQLiteデータベースの作成と接続
string connectionString = "Data Source=localdb.sqlite;Version=3;";
using (SQLiteConnection connection = new SQLiteConnection(connectionString))
{
    connection.Open();
    // テーブルの作成
    string createTableQuery = "CREATE TABLE IF NOT EXISTS SampleTable (Id INTEGER PRIMARY KEY, Name TEXT)";
    SQLiteCommand createTableCommand = new SQLiteCommand(createTableQuery, connection);
    createTableCommand.ExecuteNonQuery();
    connection.Close();
}

// テキストファイルにデータを書き込む
string filePath = "data.txt";
string data = "Sample data to be written to the file.";
System.IO.File.WriteAllText(filePath, data);

// バイナリファイルにデータを書き込む
string binaryFilePath = "data.bin";
using (FileStream fs = new FileStream(binaryFilePath, FileMode.Create))
using (BinaryWriter writer = new BinaryWriter(fs))
{
    writer.Write(123);  // int
    writer.Write(45.67);  // double
    writer.Write("Hello, Binary!");  // string
}

using Newtonsoft.Json;
using System.Collections.Generic;
using System.IO;

// データオブジェクトの定義
var dataObject = new
{
    Id = 1,
    Name = "Sample",
    Values = new List<int> { 1, 2, 3 }
};

// JSONファイルにデータを書き込む
string jsonFilePath = "data.json";
string jsonData = JsonConvert.SerializeObject(dataObject, Formatting.Indented);
File.WriteAllText(jsonFilePath, jsonData);

Install-Package System.Data.SQLite

string connectionString = "Data Source=localdb.sqlite;Version=3;";
using (SQLiteConnection connection = new SQLiteConnection(connectionString))
{
    connection.Open();
    // データベースファイルが存在しない場合は新規作成されます
}

string createTableQuery = "CREATE TABLE IF NOT EXISTS SampleTable (Id INTEGER PRIMARY KEY, Name TEXT)";
using (SQLiteCommand command = new SQLiteCommand(createTableQuery, connection))
{
    command.ExecuteNonQuery();
}

string insertQuery = "INSERT INTO SampleTable (Name) VALUES (@name)";
using (SQLiteCommand command = new SQLiteCommand(insertQuery, connection))
{
    command.Parameters.AddWithValue("@name", "John Doe");
    command.ExecuteNonQuery();
}

string selectQuery = "SELECT * FROM SampleTable";
using (SQLiteCommand command = new SQLiteCommand(selectQuery, connection))
using (SQLiteDataReader reader = command.ExecuteReader())
{
    while (reader.Read())
    {
        Console.WriteLine($"Id: {reader["Id"]}, Name: {reader["Name"]}");
    }
}

string updateQuery = "UPDATE SampleTable SET Name = @name WHERE Id = @id";
using (SQLiteCommand command = new SQLiteCommand(updateQuery, connection))
{
    command.Parameters.AddWithValue("@name", "Jane Doe");
    command.Parameters.AddWithValue("@id", 1);
    command.ExecuteNonQuery();
}

string deleteQuery = "DELETE FROM SampleTable WHERE Id = @id";
using (SQLiteCommand command = new SQLiteCommand(deleteQuery, connection))
{
    command.Parameters.AddWithValue("@id", 1);
    command.ExecuteNonQuery();
}

string filePath = "data.txt";
string data = "Sample data to be written to the file.";
System.IO.File.WriteAllText(filePath, data);

string readData = System.IO.File.ReadAllText(filePath);
Console.WriteLine(readData);

string binaryFilePath = "data.bin";
using (FileStream fs = new FileStream(binaryFilePath, FileMode.Create))
using (BinaryWriter writer = new BinaryWriter(fs))
{
    writer.Write(123);  // int
    writer.Write(45.67);  // double
    writer.Write("Hello, Binary!");  // string
}

using (FileStream fs = new FileStream(binaryFilePath, FileMode.Open))
using (BinaryReader reader = new BinaryReader(fs))
{
    int intValue = reader.ReadInt32();
    double doubleValue = reader.ReadDouble();
    string stringValue = reader.ReadString();

    Console.WriteLine($"Int: {intValue}, Double: {doubleValue}, String: {stringValue}");
}

using Newtonsoft.Json;
using System.Collections.Generic;
using System.IO;

var dataObject = new
{
    Id = 1,
    Name = "Sample",
    Values = new List<int> { 1, 2, 3 }
};

string jsonFilePath = "data.json";
string jsonData = JsonConvert.SerializeObject(dataObject, Formatting.Indented);
File.WriteAllText(jsonFilePath, jsonData);

string jsonReadData = File.ReadAllText(jsonFilePath);
var readObject = JsonConvert.DeserializeObject(jsonReadData);
Console.WriteLine(jsonReadData);

public void SyncData()
{
    if (IsNetworkAvailable())
    {
        // ローカルデータの変更をサーバーに送信
        UploadLocalChanges();
        // サーバーデータの変更をローカルに反映
        DownloadServerChanges();
    }
}

public void StartAutoSync()
{
    Timer timer = new Timer(SyncData, null, 0, 60000); // 1分ごとに同期
}

private void SyncData(object state)
{
    if (IsNetworkAvailable())
    {
        UploadLocalChanges();
        DownloadServerChanges();
    }
}

public void BiDirectionalSync()
{
    if (IsNetworkAvailable())
    {
        var localChanges = GetLocalChanges();
        var serverChanges = GetServerChanges();

        ResolveConflicts(localChanges, serverChanges);

        UploadLocalChanges(localChanges);
        ApplyServerChanges(serverChanges);
    }
}

public void ResolveConflictsManually(List<Change> localChanges, List<Change> serverChanges)
{
    foreach (var conflict in FindConflicts(localChanges, serverChanges))
    {
        // ユーザーに競合解決を依頼
        PromptUserToResolveConflict(conflict);
    }
}

public void ResolveConflictsAutomatically(List<Change> localChanges, List<Change> serverChanges)
{
    foreach (var conflict in FindConflicts(localChanges, serverChanges))
    {
        // 最終更新日時が新しい方を採用
        if (conflict.LocalChange.Timestamp > conflict.ServerChange.Timestamp)
        {
            ApplyLocalChange(conflict.LocalChange);
        }
        else
        {
            ApplyServerChange(conflict.ServerChange);
        }
    }
}

using System.Data.SQLite;

string connectionString = "Data Source=localdb.sqlite;Version=3;Password=securepassword;";
using (SQLiteConnection connection = new SQLiteConnection(connectionString))
{
    connection.Open();
    // データベース操作
    connection.Close();
}

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;

public void EncryptAndSaveData(string data, string filePath, string password)
{
    using (Aes aes = Aes.Create())
    {
        aes.Key = Encoding.UTF8.GetBytes(password);
        aes.IV = new byte[16]; // 初期化ベクトル（IV）はゼロで初期化

        using (FileStream fs = new FileStream(filePath, FileMode.Create))
        using (CryptoStream cs = new CryptoStream(fs, aes.CreateEncryptor(), CryptoStreamMode.Write))
        using (StreamWriter writer = new StreamWriter(cs))
        {
            writer.Write(data);
        }
    }
}

public bool AuthenticateUser(string username, string password)
{
    // ユーザー情報のハッシュ値を比較
    string storedHash = GetStoredPasswordHash(username);
    string inputHash = ComputeHash(password);
    return storedHash == inputHash;
}

private string ComputeHash(string input)
{
    using (SHA256 sha256 = SHA256.Create())
    {
        byte[] bytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(input));
        StringBuilder builder = new StringBuilder();
        foreach (byte b in bytes)
        {
            builder.Append(b.ToString("x2"));
        }
        return builder.ToString();
    }
}

public void BackupDatabase(string sourceFilePath, string backupFilePath)
{
    File.Copy(sourceFilePath, backupFilePath, true);
}

public void RestoreDatabase(string backupFilePath, string destinationFilePath)
{
    File.Copy(backupFilePath, destinationFilePath, true);
}

try
{
    // エラーが発生する可能性のあるコード
    int result = 10 / 0;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("Error: Division by zero.");
}
catch (Exception ex)
{
    Console.WriteLine($"Unexpected error: {ex.Message}");
}

public void LogError(Exception ex)
{
    string logFilePath = "error.log";
    using (StreamWriter writer = new StreamWriter(logFilePath, true))
    {
        writer.WriteLine($"[{DateTime.Now}] {ex.Message}");
        writer.WriteLine(ex.StackTrace);
    }
}

try
{
    // エラーが発生する可能性のあるコード
    int result = 10 / 0;
}
catch (Exception ex)
{
    LogError(ex);
    Console.WriteLine("An error occurred. Please check the log for details.");
}

// ブレークポイントを設定したい行に配置
int result = 10 / 2;
Console.WriteLine(result);

public class CustomException : Exception
{
    public CustomException(string message) : base(message) { }
}

public void PerformOperation(int value)
{
    if (value < 0)
    {
        throw new CustomException("Value cannot be negative.");
    }
    // その他の処理
}

catch (Exception ex)
{
    LogError(ex);
    Console.WriteLine("An unexpected error occurred. Please contact support.");
}

public void NotifyAdmin(Exception ex)
{
    // メール通知、ログの送信など
    SendEmail("admin@example.com", "Critical error in application", ex.Message);
}

public void SaveFieldData(FieldData data)
{
    string connectionString = "Data Source=fieldwork.sqlite;Version=3;";
    using (SQLiteConnection connection = new SQLiteConnection(connectionString))
    {
        connection.Open();
        string insertQuery = "INSERT INTO FieldData (Latitude, Longitude, Temperature) VALUES (@lat, @lon, @temp)";
        using (SQLiteCommand command = new SQLiteCommand(insertQuery, connection))
        {
            command.Parameters.AddWithValue("@lat", data.Latitude);
            command.Parameters.AddWithValue("@lon", data.Longitude);
            command.Parameters.AddWithValue("@temp", data.Temperature);
            command.ExecuteNonQuery();
        }
    }
}

public void UpdateInventory(string productCode, int quantity)
{
    string connectionString = "Data Source=inventory.sqlite;Version=3;";
    using (SQLiteConnection connection = new SQLiteConnection(connectionString))
    {
        connection.Open();
        string updateQuery = "UPDATE Inventory SET Quantity = @quantity WHERE ProductCode = @productCode";
        using (SQLiteCommand command = new SQLiteCommand(updateQuery, connection))
        {
            command.Parameters.AddWithValue("@quantity", quantity);
            command.Parameters.AddWithValue("@productCode", productCode);
            command.ExecuteNonQuery();
        }
    }
}

public void SaveProgress(LearningProgress progress)
{
    string connectionString = "Data Source=education.sqlite;Version=3;";
    using (SQLiteConnection connection = new SQLiteConnection(connectionString))
    {
        connection.Open();
        string insertQuery = "INSERT INTO Progress (StudentId, CourseId, Progress) VALUES (@studentId, @courseId, @progress)";
        using (SQLiteCommand command = new SQLiteCommand(insertQuery, connection))
        {
            command.Parameters.AddWithValue("@studentId", progress.StudentId);
            command.Parameters.AddWithValue("@courseId", progress.CourseId);
            command.Parameters.AddWithValue("@progress", progress.Progress);
            command.ExecuteNonQuery();
        }
    }
}

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Hello, World!");

        Console.Write("Enter a number: ");
        int number = int.Parse(Console.ReadLine());
        int doubledNumber = number * 2;

        Console.WriteLine($"Doubled number: {doubledNumber}");
    }
}

using System;
using System.Data.SQLite;

class Program
{
    static void Main()
    {
        string connectionString = "Data Source=sampledb.sqlite;Version=3;";
        using (SQLiteConnection connection = new SQLiteConnection(connectionString))
        {
            connection.Open();

            string createTableQuery = "CREATE TABLE IF NOT EXISTS SampleTable (Id INTEGER PRIMARY KEY, Name TEXT)";
            using (SQLiteCommand createTableCommand = new SQLiteCommand(createTableQuery, connection))
            {
                createTableCommand.ExecuteNonQuery();
            }

            string insertQuery = "INSERT INTO SampleTable (Name) VALUES (@name)";
            using (SQLiteCommand insertCommand = new SQLiteCommand(insertQuery, connection))
            {
                insertCommand.Parameters.AddWithValue("@name", "Sample Name");
                insertCommand.ExecuteNonQuery();
            }

            string selectQuery = "SELECT * FROM SampleTable";
            using (SQLiteCommand selectCommand = new SQLiteCommand(selectQuery, connection))
            using (SQLiteDataReader reader = selectCommand.ExecuteReader())
            {
                while (reader.Read())
                {
                    Console.WriteLine($"Id: {reader["Id"]}, Name: {reader["Name"]}");
                }
            }
        }
    }
}

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string filePath = "user_data.txt";

        Console.Write("Enter your name: ");
        string name = Console.ReadLine();
        File.WriteAllText(filePath, name);

        string readName = File.ReadAllText(filePath);
        Console.WriteLine($"Name from file: {readName}");
    }
}

using System;
using System.Data.SQLite;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        string connectionString = "Data Source=syncdb.sqlite;Version=3;";
        using (SQLiteConnection connection = new SQLiteConnection(connectionString))
        {
            connection.Open();
            string createTableQuery = "CREATE TABLE IF NOT EXISTS SyncTable (Id INTEGER PRIMARY KEY, Data TEXT)";
            using (SQLiteCommand createTableCommand = new SQLiteCommand(createTableQuery, connection))
            {
                createTableCommand.ExecuteNonQuery();
            }

            string insertQuery = "INSERT INTO SyncTable (Data) VALUES (@data)";
            using (SQLiteCommand insertCommand = new SQLiteCommand(insertQuery, connection))
            {
                insertCommand.Parameters.AddWithValue("@data", "Sample Data");
                insertCommand.ExecuteNonQuery();
            }
        }

        await SyncDataWithServer();
    }

    static async Task SyncDataWithServer()
    {
        using (HttpClient client = new HttpClient())
        {
            string serverUrl = "https://example.com/sync";
            var response = await client.PostAsync(serverUrl, new StringContent("Sample Data to Sync"));
            if (response.IsSuccessStatusCode)
            {
                Console.WriteLine("Data synced successfully.");
            }
            else
            {
                Console.WriteLine("Data sync failed.");
            }
        }
    }
}