常連

### 前提・実現したいこと
お世話になります。
aes暗号化した際に出力されるファイル名を**dialog.FileNameで取得した文字列で決定**したいと考えています。

aes暗号化はできているため、作成ファイルの文字列を自由に設定できるようにする部分をご教授いただけますと幸いです。
### 試したこと
aes暗号化した際の出力ファイル設定を下記のように試しております。
1.  出力パスを"C:/Users/Documents/test.aes"に設定
→**問題なくtestのaesファイルが作成される**（ファイル名が可変ではないため要修正）

2 . 出力パスを `System.IO.Path.GetFileName`で入力された文字列を読み取り、`var aesName = filename.Replace("zip", "aes");`で拡張子をaesに変更
→**暗号化ファイルが作成されない**

文字列自体は1と同じだと思うので、ファイルが作成されない理由が分かりません。

### 該当コード
```C#
//AES暗号化
        private void AesSaveAsButton_Click(object sender, RoutedEventArgs e)
        {
            var dialog = new SaveFileDialog();
            dialog.Filter = "zip|*.zip";
            if (dialog.ShowDialog() == true)
            {
                var filename = System.IO.Path.GetFileName(dialog.FileName);

                var entryName = filename.Replace("zip", "json");
                //var aesName = filename.Replace("zip", "aes");　//作成されないため一旦コメントアウト

                var json = JsonConvert.SerializeObject(_data, Formatting.Indented);
                // JSON 文字列からエンコーディング UTF-8 でバイト列を作成
                var bytes = Encoding.UTF8.GetBytes(json);
                using (var ms = new MemoryStream())
                {
                    // メモリストリーム上にZipArchiveを作成する
                    using (var zipArchive = new ZipArchive(ms, ZipArchiveMode.Create, true))
                    {
                        var entry = zipArchive.CreateEntry(entryName);
                        using (var es = entry.Open())
                        {
                            // エントリにバイナリを書き込む
                            es.Write(bytes, 0, bytes.Length);
                        }
                    }
                    // MemoryStream からバイト列を取得してファイルを作成
                    byte[] zipBytes = ms.ToArray();
                    File.WriteAllBytes(dialog.FileName, zipBytes);
                    Encode(dialog.FileName, "C:/Users/ユーザ名/Documents/test.aes");
                    //Encode(dialog.FileName, aesName); //出力されない
                }
            }
        }
        //AES複合化
        private void AesOpenAsButton_Click(object sender, RoutedEventArgs e)
        {
            var dialog = new OpenFileDialog();
            if (dialog.ShowDialog().Value)
            {
                Decode(dialog.FileName, "C:/Users/ユーザ名/Documents/test.aes");//←こちらも可変にする予定
                var file = dialog.FileName;
                try
                {
                    var reader = new StreamReader(file);
                    var json = File.ReadAllText(dialog.FileName);
                    reader.Close();
                    _data = JsonConvert.DeserializeObject<ObservableCollection<ManagementUnitData>>(json);
                }
                catch (Exception error)
                {
                    if (error.Message != null)
                        Debug.WriteLine(error.Message);
                }
                if (_data != null)
                {
                    DataContext = _data;
                }
            }
        }
        //aes暗号化
        /// <summary>
        /// 共有キー
        /// </summary>
        private const string AES_KEY = "-SENJU MURAMASA-";
        /// <summary>
        /// バッファサイズ
        /// </summary>
        private const int BUFFER_SIZE = 1024 * 4;
        /// <summary>
        /// 共有キービットサイズ
        /// </summary>
        private const int KEY_SIZE = 128;
        /// <summary>
        /// 暗号操作のビットサイズ
        /// </summary>
        private const int BLOCK_SIZE = 128;
        /// <summary>
        /// 暗号化
        /// </summary>
        /// <param name="src">入力ファイルパス</param>
        /// <param name="dst">出力ファイルパス</param>
        static public void Encode(string src, string dst)
        {
            //aes暗号化
            using (AesManaged aes = new AesManaged())
            {
                //AESインスタンスのパラメータ設定
                aes.KeySize = KEY_SIZE;
                aes.BlockSize = BLOCK_SIZE;
                aes.Mode = CipherMode.CBC;
                aes.Key = Encoding.UTF8.GetBytes(AES_KEY);
                //初期ベクターの生成
                aes.GenerateIV();
                //暗号化オブジェクトの生成
                ICryptoTransform ct = aes.CreateEncryptor(aes.Key, aes.IV);
                //出力ファイルストリーム
                using (FileStream outFs = new FileStream(dst, FileMode.Create, FileAccess.Write))
                {
                    //初期ベクター書き込み
                    outFs.Write(aes.IV, 0, aes.IV.Length);
                    //暗号変換のストリーム(暗号化)
                    using (CryptoStream cs = new CryptoStream(outFs, ct , CryptoStreamMode.Write))
                    {
                        //Deflateアルゴリズムを使用したストリーム(圧縮)
                        using (DeflateStream ds = new DeflateStream(cs, CompressionMode.Compress))
                        {
                            //入力ファイルストリーム
                            using (FileStream inFs = new FileStream(src, FileMode.Open, FileAccess.Read))
                            {
                                byte[] buf = new byte[BUFFER_SIZE];
                                for(int size = inFs.Read(buf, 0, buf.Length); size>0; size = inFs.Read(buf, 0, buf.Length))
                                {
                                    //出力ファイルへの書き込み
                                    ds.Write(buf, 0, size);
                                }
                            }
                        }
                    }
                }
            }
        }
        /// <summary>
        /// 複合化
        /// </summary>
        /// <param name="src">入力ファイルパス</param>
        /// <param name="dst">出力ファイルパス</param>
        static public void Decode(string src, string dst)
        {
            // 高度暗号化標準(AES)
            using (AesManaged aes = new AesManaged())
            {
                // AESインスタンスのパラメータ設定
                aes.KeySize = KEY_SIZE;
                aes.BlockSize = BLOCK_SIZE;
                aes.Mode = CipherMode.CBC;
                aes.Key = Encoding.UTF8.GetBytes(AES_KEY);
                // 入力ファイルストリーム
                using (FileStream inFs = new FileStream(src, FileMode.Open, FileAccess.Read))
                {
                    // 初期化ベクター(IV)読込
                    byte[] iv = new byte[aes.IV.Length];
                    inFs.Read(iv, 0, iv.Length);
                    aes.IV = iv;
                    // 複合化オブジェクト生成
                    ICryptoTransform ct = aes.CreateDecryptor(aes.Key, aes.IV);
                    // 暗号変換のストリーム（複合化）
                    using (CryptoStream cs = new CryptoStream(inFs, ct, CryptoStreamMode.Read))
                    {
                        // Deflateアルゴリズムを使用したストリーム（圧縮解除）
                        using (DeflateStream ds = new DeflateStream(cs, CompressionMode.Decompress))
                        {
                            // 出力ファイルストリーム
                            using (FileStream outFs = new FileStream(dst, FileMode.Create, FileAccess.Write))
                            {
                                // 複合化した結果を書き込む
                                byte[] buf = new byte[BUFFER_SIZE];
                                for (int size = ds.Read(buf, 0, buf.Length); size > 0; size = ds.Read(buf, 0, buf.Length))
                                {
                                    outFs.Write(buf, 0, size);
                                }
                            }
                        }
                    }
                }
            }
        }
```


【C#】dialog.FileNameで取得した文字列で作成ファイル名を決定したい

### 前提・実現したいこと
**Jsonファイルをzip化して保存したい**

お世話になります。

現在、Jsonファイルの編集ツールを作成しており保存にあたって
**json形式で保存するものとzip形式で保存するものの選択肢を与えてsaveする機能**
を作成したいと考えております。

### 試したこと
FileDialog.Filter プロパティを用いてjsonおよびzip拡張子を選べるように実装いたしました。

json拡張子を選択した場合は特に問題なく保存でき、保存したファイルを再度デシリアライズして開くことができます。

問題はzipファイルの方でして、保存自体はすることができますが
保存したzipファイルを開こうとすると
> フォルダーを開くことができません。
> 圧縮フォルダーは無効です
とエラーが起きてしまいます。

SaveFileDialogでzip化する方法をご教授いただけますと幸いです。

（別の方法でjson形式で保存するボタンとzip形式で保存するボタンも設置しようかとも考えましたがこちらの方がスマートなのかなと思っています。
**ただzip化の後aesの暗号化もしたいと考えているので、別ボタンにする方が実装する上では都合がよいのかとも考えております..**）

上記の点も踏まえてご教授いただけますと幸甚です。

### 該当のソースコード
```C#
private void SaveAsButton_Click(object sender, RoutedEventArgs e)
        {
            var dialog = new SaveFileDialog();
            dialog.Filter = "json|*.json|zip|*.zip";
            if (dialog.ShowDialog() == true)
            {
                var json = JsonConvert.SerializeObject(_data, Formatting.Indented);
                File.WriteAllText(dialog.FileName, json);
            }
        }
```
```wpf
<Button
    Click="SaveAsButton_Click"
    Content="保存"
/>
```
定義
```C#
public MainWindow()
		{
			InitializeComponent();
			DataContext = _data;
		}

private void OpenButton_Click(object sender, RoutedEventArgs e)
		{
			var dialog = new OpenFileDialog { Filter = "json|*.json", };
			if (dialog.ShowDialog() == true)
			{
				var json = File.ReadAllText(dialog.FileName);
				_data = JsonConvert.DeserializeObject<ObservableCollection<PersonalData>>(json);
				DataContext = _data;
			}
		}
```

【C#】Jsonファイルをzip化して保存したい

現在、アプリケーション上で画面レイアウトの設定をGUIで変更する仕組みを実装しています。
ちょっと分かりにくいかもしれませんが。

![![画面例](2356dd8327a97620107d6ac43d6b40db.png)

画像のようなパネルを表示して、パネルの境界線をドラッグすることで①と②のサイズを変更して、
それぞれのパネルのサイズをファイルに保存するというものを考えています。

このパネルはユーザーコントロールを定義して、GridとGridSplitterを使っています。
依存関係プロパティも定義しており、外部からパネルの幅と高さをBindできるようにはしてあります。

この外部からBindされた値(変数)をどのように使用したら考えているような動作になるか分からず困っています。
理想はGridSplitterを動かせばBindされた変数にサイズの変わったGridの幅がそのままBind元に行くというのをイメージしているのですが、
Bindした変数の値が変わらないため、おかしな見た目になってしまいます。
どのようにすればいいか教えていただけないでしょうか？

![](6cab33c41cd32d34396f43bbc65856ba.png)

下記に現在のソースを書いておきます。
日本語がおかしな部分があるかもしれません、足りない情報があれば指摘していただければすぐに追加いたしますので、
よろしくお願いいたします。

```XAML
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="*"/>
            <ColumnDefinition Width="1"/>
            <ColumnDefinition Width="*"/>
        </Grid.ColumnDefinitions>

        <Grid Grid.Column="0" Background="Red" HorizontalAlignment="Stretch" Width="{Binding Panel1Width, ElementName=root}" >
            <TextBlock Text="①" TextAlignment="Center" VerticalAlignment="Center" FontSize="30" FontWeight="UltraBold"/>
        </Grid>

        <Grid Grid.Column="2" Background="Blue" HorizontalAlignment="Stretch" Width="{Binding Panel2Width, ElementName=root}">
            <TextBlock Text="②" TextAlignment="Center" VerticalAlignment="Center" FontSize="30" FontWeight="UltraBold"/>
        </Grid>

        <GridSplitter Grid.Column="1" ResizeDirection="Columns" HorizontalAlignment="Stretch"/>
    </Grid>
```

```C#
    public partial class Layout2Panel : UserControl
    {
        public Layout2Panel()
        {
            InitializeComponent();
        }

        public double Panel1Width
        {
            get => (double)GetValue(Panel1WidthProperty);
            set => SetValue(Panel1WidthProperty, value);
        }
        public static readonly DependencyProperty Panel1WidthProperty =
            DependencyProperty.Register(
                "Panel1Width",
                typeof(double),
                typeof(Layout2Panel),
                new FrameworkPropertyMetadata(0.0, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault));

        public double Panel1Height
        {
            get => (double)GetValue(Panel1HeightProperty);
            set => SetValue(Panel1HeightProperty, value);
        }
        public static readonly DependencyProperty Panel1HeightProperty =
            DependencyProperty.Register(
                "Panel1Height",
                typeof(double),
                typeof(Layout2Panel),
                new FrameworkPropertyMetadata(0.0, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault));

        public double Panel1X
        {
            get => (double)GetValue(Panel1XProperty);
            set => SetValue(Panel1XProperty, value);
        }
        public static readonly DependencyProperty Panel1XProperty =
            DependencyProperty.Register(
                "Panel1X",
                typeof(double),
                typeof(Layout2Panel),
                new FrameworkPropertyMetadata(0.0, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault));

        public double Panel1Y
        {
            get => (double)GetValue(Panel1YProperty);
            set => SetValue(Panel1YProperty, value);
        }
        public static readonly DependencyProperty Panel1YProperty =
            DependencyProperty.Register(
                "Panel1Y",
                typeof(double),
                typeof(Layout2Panel),
                new FrameworkPropertyMetadata(0.0, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault));

        public double Panel2Width
        {
            get => (double)GetValue(Panel2WidthProperty);
            set => SetValue(Panel2WidthProperty, value);
        }
        public static readonly DependencyProperty Panel2WidthProperty =
            DependencyProperty.Register(
                "Panel2Width",
                typeof(double),
                typeof(Layout2Panel),
                new FrameworkPropertyMetadata(0.0, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault));

        public double Panel2Height
        {
            get => (double)GetValue(Panel2HeightProperty);
            set => SetValue(Panel2HeightProperty, value);
        }
        public static readonly DependencyProperty Panel2HeightProperty =
            DependencyProperty.Register(
                "Panel2Height",
                typeof(double),
                typeof(Layout2Panel),
                new FrameworkPropertyMetadata(0.0, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault));

        public double Panel2X
        {
            get => (double)GetValue(Panel2XProperty);
            set => SetValue(Panel2XProperty, value);
        }
        public static readonly DependencyProperty Panel2XProperty =
            DependencyProperty.Register(
                "Panel2X",
                typeof(double),
                typeof(Layout2Panel),
                new FrameworkPropertyMetadata(0.0, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault));

        public double Panel2Y
        {
            get => (double)GetValue(Panel2YProperty);
            set => SetValue(Panel2YProperty, value);
        }
        public static readonly DependencyProperty Panel2YProperty =
            DependencyProperty.Register(
                "Panel2Y",
                typeof(double),
                typeof(Layout2Panel),
                new FrameworkPropertyMetadata(0.0, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault));
    }

```

GridSplitterを使用して変更したGridのサイズを取得したい

現在3つのアプリを開発中で、それらは全て画面に表示する文言をjson形式にて管理する予定です。
他国でも使用されるアプリのため、その文言管理用jsonファイルは各国の文言を記載したものがそれぞれ用意されることとなります。
バージョンアップにて新しく文言が追加される度、英語を基準に各国の方が翻訳し、その国ごとの文言管理用jsonファイルを作成するための、技術者でない人でも扱えるような文言変更ツールが必要となります。
今回はその文言変更ツールの作成です。

ツールの開発環境はVS2008、Frameworkは3.5で作成しています。
その読み込むjsonファイルの中身が以下のような内容です。

------------------------------------------------------------
{
	"LoginScreen":{
		"label_title":"Login Screen",
		"label_userId":"User ID",
		"label_password":"Password",
		"button_login":"LOGIN"
　　　　　　　←(増える可能性あり)
	},
	"UserLIstScreen":{
		"label_title":"User List",
		"label_userId":"User ID",
		"label_userName":"User Name",
		"label_userTell":"TEL",
		"label_phone":"Phone",
		"label_save":"SAVE"
　　　　　　　←(増える可能性あり)
	},
	"SettingListScreen":{
		"label_title":"Setting",
		"label_storeName":"Store Name",
		"label_language":"Language",
		"button_save":"SAVE"
　　　　　　　←(増える可能性あり)
	}
　　　　←(更に他画面が増える)
}

------------------------------------------------------------
画面ごとに区切られていて、その中にメッセージのkeyとvalue　といった形になってます。
画面名・メッセージのkey・valueはそれぞれ全て動的な上、今後文言が増えることもありますし、画面が増えることもあります。
その度にツールを修正するようなことはしたくありません。

やりたいこととしては、
１．jsonファイルを読み込み、データをメモリに保持。
２．フォームのDataGridViewに値をセット、画面にて編集できるようにする。
　 （その際、変更された文言・追加された文言・既存文言が分かるようにする。）
３．保存ボタン押下時に、編集した新しいjsonファイルを排出。
といった内容です。



現在jsonファイルの読み込みの段階で、読み込むには別クラスによる型宣言が必要だと認識しているのですが、キーが動的なゆえに別クラスによる型宣言がうまくできず、どう読み込めばいいのか分からなくて詰まっています。
→なんとか読み込み、切り分け、画面に表示までできました。
ただ、やり方が少し強引というか…
```C#
        private void EditScreen_Load(object sender, EventArgs e)
        {


            try
            {
                var jScreen = JObject.Parse(File.ReadAllText("D:\MessageWork\En_Old\risou.json", Encoding.Default));

                foreach (var MenuMsg in jScreen.Properties())
                {
                    MessageBox.Show(Regex.Replace(MenuMsg.ToString(), ".*{", "{"));
                    var dic = JsonConvert.DeserializeObject<Dictionary<string, string>>(Regex.Replace(MenuMsg.ToString(), ".*{", "{"));
                    string sss = "";
                    foreach (var ScreenMsg in dic.Keys)
                    {
                        sss += ScreenMsg.ToString() + "  :  " + dic[ScreenMsg].ToString() + "\r\n";
                    }
                    MessageBox.Show(sss);
                    
                }

            }
            catch (Exception ex)
            {
                string msg = string.Format("Error Occurred! \r\n\r\n{0}", ex.ToString());
                MessageBox.Show(msg);
            }
        }
```

JObject.Parseを使って画面ごとに切り出し、
切り出した後の左側の部分を無理やりReplaceでカット
JsonConverter.DeserialiseObjectを通して{}の部分を読み込み。
画面に表示…といった感じです。

出来た、としてもいいのですが、あまり綺麗ではないかな…と感じています。
これ以外に「この方法の方が良い」といったような方法は無いでしょうか…