常連

注目の的

自己紹介

実行結果として`GR2`に`0043`が格納される理由がわかりません。

LD命令で第2項の`HEX`と第3項の`GR1`を加算した結果から実行アドレスを読み込んで、その値を`GR2`に格納するという認識しています。
ですがHEXは'0123456789ABCDEF'なので16文字を1語ずつ分けて、文字コードとしてメモリに格納されているので、上記の認識だとどのようにして処理がなされているのか理解できませんでした。
そもそも、この場合第二項に複数のメモリをオペランドとして指定してないのでしょうか？

```CASLⅡ
PRG000    START
          RPUSH
          LAD   GR1,#000C
          LD    GR2,HEX,GR1
          RET
DATA      DS    1
HEX       DC    '0123456789ABCDEF'
          END
```
実行環境は以下のシュミレーターです
http://www.chiba-fjb.ac.jp/fjb_labo/casl/casl2.cgi

ご回答よろしくお願いします。

CASLⅡ LD命令でインデックス修飾アドレッシングを使った時の処理について

declativeとimperativeという言葉に出くわしました。日本語の訳をググったところ、それぞれ宣言的、命令的とありました。

これらは具体的にどういった意味で、それぞれのメリット、デメリットは何なのでしょうか？

どちらか一方が良いもので、そちらを目指そうといった類のものなのでしょうか？

□宣言的
頼めば後は上手いこと求めてること結果を出してくれる

ファサード的な？

□命令的
自分でどうやって自分の求めている結果を導くかまで書く必要がある。

□メモ
どちらか一方になるというよりは、宣言的寄りであったり、命令的寄りだったり、度合いがあるもの。

宣言的と命令的の意味、違いは？

JavaScriptにおいて、JavaやC++で言うところのメンバ関数を実現しようとすると、コンストラクタ関数内で定義する方法と、プロトタイプにメソッドを追加する方法があると思います。これについて、前者はオブジェクトが生成されるたびにメソッドが追加されるため効率が悪い、と聞きました。例えば末尾に記した例では、new Person()が呼ばれるたびにsay()が追加されることが冗長である、ということだと理解しています。

この話を聞いて以降、私はプロトタイプにメソッドを定義するようにしています。幸いなことにまだ困った状況に遭遇していません(Javaのクラス／オブジェクトのように使えている)。「コンストラクタ関数内でメソッドを定義せざるを得ないケースはほとんど無い」とさえ思っています。

しかし、ふと気付きました。これは勉強不足だ、単に経験不足だと。

そこで書籍を読んでいるところなのですが、まだ「コンストラクタ関数内でメソッドを定義したほうが良い」と思える状況に出会えていません。

コンストラクタ関数内でメソッドを定義した方が良い、せざるを得ないような状況というか、イディオムを紹介していただけないでしょうか？

コンストラクタ関数内にメンバ関数を定義：
```javascript
var Person = function(name) {
  this.name = name;
  this.say = function() { // こうやってメソッドを定義することはあるのだろうか？
    return "I am " + this.name;
  };
};
```

プロトタイプにメソッドを追加する：
```javascript
var Person = function(name) {
  this.name = name;
};
Person.prototype.say = function() {
  return "I am " + this.name;
};
```

「コンストラクタ関数内でメソッドを定義せざるを得ないケースはほとんど無い」という認識はどうなんでしょう？

正規表現についての質問です。

以下のどちらかの場合に正規表現でマッチさせたいと考えています。
「数値」　　：正の整数値
「入力無し」：空白(全半スペース問わず)は該当させず、本当に入力が無い場合のみが対象
※java等での```aaa = ""```にあたる扱いのもの

数値に関しては```^[0-9]+$」```と表現しているのですが、「入力無し」にマッチさせる方法で悩んでいます。

繋げ方としては```|```(パイプ)で繋げればいいと思っています。

whitespaceの指定は空白ですし、```[^]```のような否定形で入力があることを表現できればとも思ったのですが、```[^]```は特定の文字を指すもののようでうまく使えていません。
また、ワイルドカードである```.```(ピリオド)もどうすれば否定系で使えるのかが分からない状態です。

コードを記述すればいいのですが、本処理をGUIで行わなければならず、GUIで使用するコンポーネント数を出来る限り削減するという目標もあり、正規表現で実現できればと思っています。

正規表現で入力無しをマッチさせるというのも変な話なのですが、これが実現できれば大変助かります。
正規表現については分からないことも多く、皆様のお力添えを頂ければ幸いです。
以上、宜しくお願い致します。

追記：
環境はJava系のGUIツール(デザイナー)です。
ツール名は諸事情で出せないのですが、JavaベースのGUIですので恐らく正規表現のコンポーネントの裏ではmatcher()が動作しているのではないかと予想しています。

正規表現での文字なしを該当させたい

### 困っていること

「<>c__DisplayClass11_0.」のような書き方は何を表しているのでしょうか？
```
   System.Web.Mvc.Async.<>c__DisplayClass11_0.<InvokeActionMethodFilterAsynchronouslyRecursive>b__0() +58
   System.Web.Mvc.Async.<>c__DisplayClass11_2.<InvokeActionMethodFilterAsynchronouslyRecursive>b__2() +228
   System.Web.Mvc.Async.<>c__DisplayClass7_0.<BeginInvokeActionMethodWithFilters>b__1(IAsyncResult asyncResult) +10
```

### 試したこと

以下の言葉でググってみるも解説記事には出会えませんでした。
「スタックトレース 読み方」
「ASP.NET MVC スタックトレース 読み方」
「C# スタックトレース 読み方」

System.Web.Mvc.Async名前空間のクラスを表しているとは思うのですが...
どなたかわかる方ご教授いただけますと幸いです。

ASP.NET MVCのスタックトレースの意味を知りたい

初歩的な質問失礼いたします。

クラスとメソッドにstaticを付けることにはどのような意味があり、メリットは何でしょうか？

自分で調べたところ、
```
staticクラス  ：インスタンスを作成しないクラスであることを明示する。(コンパイルエラーを発生させる)
staticメソッド：インスタンスを作成せずに使える。
```
といった概要であることは理解できましたが、あまり利点を感じません。

何か上記以外に、staticにする必要性や利点があるのでしょうか？
staticクラス、staticメソッドって使う必要ないのでは・・・？と思っている次第です。

また、引数fugaを持つstaticメソッドhoge(stirng fuga)を、複数スレッドから呼び出した際、
他のスレッドのfugaの値を書き換えてしまったりしないのでしょうか？

以上、よろしくお願いいたします。
(タグが不適切でしたらすみません)

staticクラス、staticメソッドの意味と利点

Githubの基本的なことを実践入門書にて学習しております。

マージについて実践しているのですが、ターミナルにて下記のように入力した後にどのように操作すれば良いのか分からず苦戦しております。。

```
$ git merge --no-ff feature-A

Merge branch 'feature-A'

# Please enter a commit message to explain why this merge is necessary,
# especially if it merges an updated upstream into a topic branch.
#
# Lines starting with '#' will be ignored, and an empty message aborts
# the commit.
~                                                                                  
~                                                                                  
~                                                                                  
~                                                                                  
~                                                                                  
~                                                                                  
~                                                                                  
~                                                                                  
~                                                                                  
~                                                                                  
~                                                                                  
~                                                                                  
~                                                                                  
~                                                                                  
~                                                                                  
~                                                                                  
~                                                                  
```

本には、
```
ブランチからマージしたことを明確に歴史に残すためにマージコミットを作成しましょう。そのため、--no-ffオプションを付与してマージします。
```
とあります。

その後、
```
デフォルトでfeature-Aブランチからのマージである旨が記述されているので、コミットメッセージは特別に変更を加えなくても構いません。エディタで表示されている内容を保存して、エディタを終了してください。すると次のように表示されます。
```
コード
```
Merge made by the 'recursive' strategy.
README.md | 2++
1 file change, 2 insertions(+)
```

本には上記のように書いてあるのですが、どのように操作したらそうなるのか全く分からずにおります。。

ネットでも検索しながら関連記事を探していますが、ご存知の方いらっしゃいましたらご教授頂けますと幸いです。

Githubのmergeについて

プロパティとメソッドは何を基準に使い分けるのでしょうか？
プロパティは状態、メソッドは振る舞いというのはわかるのですが
例えば人名を表す値オブジェクトがあったとします。

```c#
public sealed class PersonName : ValueObject
{
    private string _firstName;
    private string _lastName;

    public PersonName(string firstName, string lastName)
    {
        _firstName = firstName;
        _lastName = lastName;
    }

    ...
}
```

このオブジェクトに画面表示用の値を追加する場合

```C#
public string DisplayValue => $"{_firstName} {_lastName}";
```

のようにプロパティにすべきか

```C#
public string ToDisplayValue() => $"{_firstName} {_lastName}";
```

のようにメソッドにすべきか、判断基準がよくわかりません。
デバッグ時には、値がすぐ見られるのでプロパティのほうが便利ですが、その分IDEに負荷がかかる（遅くなる）のかなと思います。
上記は簡単なケースなのでどちらでも変わらないかもしれませんが、より複雑になった場合に何を基準に使い分けをおこなうのでしょうか？

プロパティとメソッドの使い分け

### 前提・実現したいこと

はじめまして。
c#で、あるクラスを作成しているのですが、
プロパティの扱いに関して質問があります。

プロパティは一般には、クラス内のメンバ変数に外からアクセスするときの
インターフェース的なもので、クラス内部のコードでは対応するメンバ変数を
使うという理解なのですが、クラス内部でそのままプロパティをメンバ変数のように
使用するのは良くないのでしょうか。


### 該当のソースコード

例えば、あるクラスの中身が以下のようだとして、
クラス内で、プロパティ"Name"をそのまま使っていますが、
何か問題あるのでしょうか。

```csharp
private string _name;
public string Name
{
  get { return this._name; }
  set { this._name = value; }
}

private string Hogehoge()
{
    Name = "yamada"; // this._name = "yamada";のほうが適切？
    var xxx = Name; // var xxx = this._name;のほうが適切？

    return xxx;
}

```

またそもそも、特にアクセスレベルの制限などする必要のないような場合、
以下のように、メンバ変数を省略するというのはありでしょうか。
(この場合、単にメンバ変数```pulic string Name;```を使うのとほぼ同じ・・・？)
```csharp
public string Name { get; set; }

private string Hogehoge()
{
    Name = "yamada"; 
    var xxx = Name; 

    return xxx;
}

```

よろしくお願いいたします。

クラス内でプロパティを通してフィールドにアクセスすることの是非

こんにちは。

Visual Studio 2019 16.8.1にアップデートされたものを使っています。
新規のプロジェクトを作ると、ターゲットのフレームワークが.NET 5.0しか選べません。
![イメージ説明](9058744c820d22719119055e17573268.png)

プロジェクトの種類はWindowsアプリケーションです。
![イメージ説明](98d697d4ad276be52225f7454fe0e9de.png)
行いたいことは、RS-232Cのシリアル通信をして計測器からデータを吸い上げることと、設定を計測器に指示することです。
「計測器」→「PC」→CSVへの書き出し
程度ができれば十分です。

ちなみに古いプロジェクトを開くと.NETはよりどりみどりです。
![イメージ説明](bb663713bbd465c79453934f937443e5.png)

新規でプロジェクトを作成すると、もう古い.NETのバージョンを選べない仕様になってしまったのでしょうか。
ネットワークに繋げない古いPCを計測器専用にして、そこでデータを取得したり長期ランニングに…と思っていたのですが、正直参ったなという感じです。
どなたかご存じの方はいらっしゃいませんか。

Visual Studio 16.8.1 新規プロジェクトのターゲットフレームワーク選択

##背景状況
[https://qiita.com/laughter/items/e9cf666e0430acc39e95](https://qiita.com/laughter/items/e9cf666e0430acc39e95)
こちらの記事を読んでいたところ、冒頭に、

```c#
class Hoge
{
    private readonly IList<int> _list = new List<int>();
}
```

という記述がありました。
これまで自分は「List<int>」などは頻繁に使っていましたが、「IList<int>」という宣言は使ったことがなく、困惑しました。

##知りたいこと
以下、ご回答頂けると嬉しいです。よろしくお願いいたします。

######1.なぜインターフェース型の変数などというものが宣言可能なのか
自分の理解では、インターフェースとはあくまでも実装の型宣言のみしかしておらず、具体的な実装が入っていない「もぬけの殻」であり、実運用のためには必ず当該インターフェースを実装したクラスを作る必要がある、と考えていました。

######2.インターフェース型変数を用いることのメリットは何か
List<T>型ではなく、あえてIList<T>を使うと、何が良いのか。

「IList」と「List」の使い分け

こんにちは。今回、if文を使ってJavaScriptの勉強としておみくじを作りました。
if文については分かるのですが、functionやuse strict、addEventListnerといった関数は初めて聞いたのでqiitaに載ってあったコードのvar関数をlet関数に置き換えるくらいしかできませんでした。
そこでなのですが、先述の関数を覚えながら脳内だけでもコードを書けるようになる方法を教えてください。
よろしくお願いします。



(function(){
  'use strict';

  let btn = document.getElementById('btn');

  btn.addEventListener('click', function(){
    var n = Math.random()
    if(n < 0.3){
      this.textContent = '大吉'; // 30%
    }else if (n < 0.45){
      this.textContent = '吉';  // 15%
    }else if (n < 0.60){
      this.textContent = '中吉';  // 15%
    }else if (n < 0.85){
      this.textContent = '小吉';  // 15%
    }else{
      this.textContent = '凶';  // 15%
    }

  });
  btn.addEventListener('mousedown', function(){
    this.className = 'pushed';
  });
  btn.addEventListener('mouseup', function(){
    this.className = '';
  });
})();

Java Scriptの処理を何も見ずに書けるようになる方法を教えてください。

Rxの勉強をしており、.NETのイベントハンドラ（今回はMouseMoveイベント）を、
IObservableシーケンスに変換してくれるFromEventメソッドの理解を深めようとしています。
ネットのサンプルコードを見ていると以下のようなコードによく出くわします。
```
IObservable<MouseEventArgs> mouseMove = Observable.FromEvent<MouseEventHandler, MouseEventArgs>(
        h => (s, e) => h(e),
        h => this.MouseMove += h,
        h => this.MouseMove -= h);
```
これはFromEventメソッドの中でも下記オーバーロードを利用している認識です。
```
IObservable<TEventArgs> FromEvent<TEventHandler, TEventArgs>(
　　　Func<Action<TEventArgs>, TEventHandler> conversion,
　　　Action<TEventHandler> addHandler,
　　　Action<TEventHandler> removeHandler)
```

この３つの引数とサンプルコードの引数がどのように対応しているのかを教えていただきたいです。
現段階では引数１：conversionについて考えて迷路に迷い込んでいる状態です。
仰々しく書くと
**『引数convserionに「イベント情報（TEventArgs）を引数として受け取るデリゲート（Action）」を渡してください。戻り値でイベントハンドラ（TEventHandler）を返却します。』**
という理解なのですが、それがなぜhだのsだのeだので表現出来ているのかが謎です。
どなたか分かりやすくご説明いただけないでしょうか？

【C#】【Rx】Observable.FromEventメソッドの引数が何を表現しているのかが分かりません

お世話になります。
C#のコードの書き方について質問です。

以下のような、privateフィールドと、単純なアクセサが設定されたコードがあり、

```C#
private bool flag = false;
public bool GetFlag(){ return flag; }
public void SetFlag(bool value){ flag = value; }
```

同クラス内では flag = true のような直接代入、
他クラスでは SetFlag(true) のようなアクセサで代入となっていました。

個人的にはアクセサに統一したほうが、メンテナンスしやすいと考えるのですが、このように分けて書く理由を教えたいただければ幸いです。
私としては、処理が早くなるくらいしか思いつかず。。。

どうぞよろしくお願いいたします。

【補足】
C++からの移植コードのため、プロパティとして定義されていません。

C# 同クラスでは直接代入、他クラスではSetterの理由

######**C#のtry~catch句を使った実装について**
お世話になっております。
物凄く初歩的な質問です。

掲題の件の設計・思想についてわからない所があります。
プログラムの例外処理は大体以下のようにコードを書いております。

```lang-C#
public void Hoge(){
    try
    {
        //処理X
    }
    catch(Exception ex)
    {
        Log(ex); //例外の内容をログ出力
    }
}
```

上記コードのメリットは処理Xにて問題発生時、
- **例外が補足されるためプログラムは終了せず、運用に支障を来たしにくくなる**
- **全ての例外が補足されるため、ログ出力されたときに不具合の原因を特定しやすい**

ことです。

しかし、デメリットも当然あると思っており

- **OutOfMemoryExeption等、本来開発側が想定していないエラーを補足してしまうため、**
**例外発生後は意図しない処理が起きる可能性がある**

ことは良くないな…と思っております。

理想としては
- 想定しているエラー
- 想定していないエラー

を実装する処理によって逐次対応(かつ楽に実装)できたら良いな…と思っております。


最適解はあるのでしょうか。
皆様はどのように例外処理を実装されていますか。

ご教授のほどよろしくお願いします。

【C#】try~catchのcatch部分はどう実装すべきか

### 前提・実現したいこと
C#でイベントについて学習しています。

独自のEventArgsを使用する際に、色々なサンプルでEventArgsを継承すると書かれているのですが
継承が必要な理由がよくわかりません。
以下、TextBoxでXキーが押された際に実行されるイベントを作ってみました。

この際、XKeyDownArgsでEventArgsを継承してもしなくても挙動は変わらないように見えます。
EventArgsを継承することの利点や、しなければならない理由が何かあるのでしょうか？

よろしくおねがいします。


### 該当のソースコード

```C#
public partial class Form1 : Form
{
    private event EventHandler<XKeyDownArgs> XKeyDown;

    public Form1()
    {
        InitializeComponent();
    }

    private void Form1_Load(object sender, EventArgs e)
    {
        XKeyDown += XKeyDownMessage;
    }

    private void TextBox1_KeyDown(object sender, KeyEventArgs e)
    {
        if (e.KeyCode == Keys.X)
        {
            XKeyDown?.Invoke(sender, new XKeyDownArgs());
        }
    }

    private void XKeyDownMessage(object sender, XKeyDownArgs e)
    {
        MessageBox.Show("Xキーが押されました");
    }
}

// EventArgsを継承してもしなくても問題なく動作する
public class XKeyDownArgs : EventArgs
{
}
```

EventArgsを継承したクラスを使用する意味はなんでしょうか？

### 前提・実現したいこと
TrimEndメソッドを使って、
末尾が「-fe」の英単語を複数形「-ves」に変換するプログラムを作ったのですが、
「knife」は正しく「knives」に変換されたのですが、
「coffeeffefe」(実在しない単語ですが)と入力するとなぜか「coves」と変換されてしまいました。(coffeeffevesと変換されるようにしたかった。)

こうなった原因を教えていただきたいです。
### 該当のソースコード
C#
```ここに言語名を入力
using System;

class Sample
{
    public static void Main()
    {
        string word1 = "knife".TrimEnd('f','e') + "ves";
        string word2 = "coffeeffefe".TrimEnd('f','e') + "ves";

        Console.WriteLine(word1);
        Console.WriteLine(word2);
    }
}
```

### 試したこと

TrimEndメソッドについてネットで調べてみたところ、このページhttps://www.sejuku.net/blog/44406
によれば、TrimEnd(Char,Char)の形で書けば末尾2文字を削除できるというような事が書かれており、実際に「knife」は正しくできましたが、「coffeeffefe」は駄目でした。

C#のTrimEndメソッドの処理結果が意味不明になります

子フォームから親フォームの関数を実行させたいのですがどのようにすればいいでしょうか？
実現させたいこと
親フォームがarray値(x)を所持して子のclickイベントで親フォームのarray値(x)を変更し、子にもarray値(x)を反映させたいです。
親から子は操作できるので上記の「子にもarray値(x)を反映させたいです。」は無視しても大丈夫です。

親Form1
子Form2


```親Form1
//子フォーム_モードレスで呼び出し。

private int[] x= new int[3];//配列宣言
form2 child = new form2();
child.show();  
///
public void resize(){//この処理を子から呼び出したい
//処理
x[0] = 3;
}
```

```子Form2
//子フォームをクリックしたら呼び出す
this.Click += new EventHandler(this.formsclick);

public void formsclick(ojbect sender, EventArgs e){
//親のresize()を呼び出したい
}
```








visual studio 2019
.NET Framework 4.6.1
windows 10 64bit

windows forms 子フォームから親フォームの関数実行

C# Form1に設置したTimer1で時間をラベルに表示しています。

これを、Form1から開いた、Form2　に設置したボタン　で
button1_Click　で　Timer1 をスタート。
button2_Click　で　Timer1 をストップ。
を行いたいのですが、どの様にすれば良いのか、ご教授お願い致します。

Form1　内で
　timer1.Stop();
　timer1.Start();
は、出来たのですが、別のフォームからですと、どの様に記述すれば、操作出来るのでしょうか？


■Form1　に、時間を表示するだけの　label1　があります。

```
using System;
using System.Windows.Forms;

namespace TimerTest
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            timer1.Interval = 200;
            timer1.Enabled = true;
        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            DateTime d = DateTime.Now;
            label1.Text = d.ToString() ;
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Form2 form2 = new Form2();
            form2.Show();
        }
    }
}

```
■Form２　に　ボタンを二つ設置しました。
```
using System;
using System.Windows.Forms;
namespace TimerTest
{
    public partial class Form2 : Form
    {
        public Form2()
        {
            InitializeComponent();
        }
        private void button1_Click(object sender, EventArgs e)
        {
            //Form1 の timer1 をスタートする。 
        }

        private void button2_Click(object sender, EventArgs e)
        {
           //Form1 の timer1 をストップする。 
        }
    }
}
```

C# Form1に設置したTimer1をForm2から操作したいです。

大学でプログラミングを学んでいるものです。
最近プログラミング言語の環境開発のときによく「環境変数」とか「パスを通す」とかといった言葉をよく耳にします。そもそも環境変数とは何なのでしょうか？自分でもいろいろ調べてみましたが専門用語を使った説明が多く何を言っているのかさっぱりわかりません。そこで下記のことについてできるだけわかりやすく説明してくださると助かります。
0. 環境変数とは何か？
0. どういった場面で環境変数を利用する/利用されているのか？
0. pathを通すとは何か？

回答よろしくおねがいします。