'var'を使用するとパフォーマンスに影響がありますか？

以前、私はなぜvarキーワードが多くの例で見られるのかについて質問しましたが、匿名型にのみ必要であるにもかかわらず、それでもコードを「より速く」/「より簡単に」書くために使用されるという答えを得ました。

続いて、このリンク（「C＃3.0 -ヴァールされていないOBJEC」） IソーvarIL内の正しい種類までコンパイルされる（あなたは記事下のほぼ中間に表示されます）。

私の質問は、もしあれば、ILコードがvarキーワードtake をどれだけ使用するかであり、どこで使用しても、コードのパフォーマンスを測定可能なレベルに近づけることになるでしょうか？

varキーワードに追加のILコードはありません。結果のILは、非匿名型と同じでなければなりません。使用するつもりのタイプがわからないためにコンパイラーがそのILを作成できない場合、コンパイラー・エラーが発生します。

唯一のトリックはvar、タイプを手動で設定した場合にインターフェースまたは親タイプを選択した可能性がある正確なタイプを推測することです。

8年後の更新

私の理解が変わったので、これを更新する必要があります。varメソッドがインターフェースを返す状況ではパフォーマンスに影響を与える可能性があると私は今信じていますが、あなたは正確なタイプを使用したでしょう。たとえば、このメソッドがある場合：

IList<int> Foo()
{
    return Enumerable.Range(0,10).ToList();
}

メソッドを呼び出すには、次の3行のコードを検討してください。

List<int> bar1 = Foo();
IList<int> bar = Foo();
var bar3 = Foo();

3つすべてが期待どおりにコンパイルおよび実行されます。ただし、最初の2行は完全に同じではなく、3行目は1行目ではなく2行目と一致します。のシグネチャFoo()はを返すことなIList<int>ので、これがコンパイラがbar3変数を構築する方法です。

パフォーマンスの観点からは、ほとんど気付かないでしょう。ただし、3行目のパフォーマンスが1行目のパフォーマンスほど速くない場合があります。bar3変数を使い続けると、コンパイラーは同じ方法でメソッド呼び出しをディスパッチできない場合があります。

ジッタがこの差を消す可能性がある（たぶん均等になる）ことに注意してください。ただし、保証はされていません。一般に、varパフォーマンスの点では依然として非要因であると考える必要があります。確かに、dynamic変数を使用するようなものではありません。しかし、それがまったく違いをもたらさないと言うことは、それを過大評価するかもしれません。

Joelが言うように、コンパイラーはコンパイル時に var型がどうあるべきかを計算します。事実上、それはコンパイラーがキーストロークを保存するために実行するトリックにすぎません。

var s = "hi";

に置き換えられます

string s = "hi";

ILが生成される前にコンパイラーによって。生成されたILは、文字列を入力した場合とまったく同じです。

まだ誰もリフレクターについて言及していないので...

次のC＃コードをコンパイルすると、

static void Main(string[] args)
{
    var x = "hello";
    string y = "hello again!";
    Console.WriteLine(x);
    Console.WriteLine(y);
}

次に、リフレクターを使用すると、次のようになります。

// Methods
private static void Main(string[] args)
{
    string x = "hello";
    string y = "hello again!";
    Console.WriteLine(x);
    Console.WriteLine(y);
}

したがって、答えは明らかに実行時のパフォーマンスへの影響がないことです！

次のメソッドの場合：

   private static void StringVsVarILOutput()
    {
        var string1 = new String(new char[9]);

        string string2 = new String(new char[9]);
    }

IL出力はこれです：

        {
          .method private hidebysig static void  StringVsVarILOutput() cil managed
          // Code size       28 (0x1c)
          .maxstack  2
          .locals init ([0] string string1,
                   [1] string string2)
          IL_0000:  nop
          IL_0001:  ldc.i4.s   9
          IL_0003:  newarr     [mscorlib]System.Char
          IL_0008:  newobj     instance void [mscorlib]System.String::.ctor(char[])
          IL_000d:  stloc.0
          IL_000e:  ldc.i4.s   9
          IL_0010:  newarr     [mscorlib]System.Char
          IL_0015:  newobj     instance void [mscorlib]System.String::.ctor(char[])
          IL_001a:  stloc.1
          IL_001b:  ret
        } // end of method Program::StringVsVarILOutput

C＃コンパイラは、varコンパイル時に変数の真の型を推測します。生成されたILに違いはありません。

つまり、明確に言うと、遅延コーディングスタイルです。私は選択を考えると、ネイティブ型を好みます。この余分な「ノイズ」を取り、コード/デバッグ時に自分が考えていることを正確に読み書きできるようにします。*肩をすくめる*

読んだ内容をきちんと理解していないと思います。正しいタイプにコンパイルされる場合、違いはありません。私がこれをするとき：

var i = 42;

コンパイラーはそれがintであることを認識し、私が書いたかのようにコードを生成します

int i = 42;

あなたがリンクした投稿が言うように、それは同じタイプにコンパイルされます。これは、ランタイムチェックやその他のコードを必要とするものではありません。コンパイラは、型が何である必要があるかを理解し、それを使用します。

varを使用しても、実行時のパフォーマンスコストはありません。ただし、コンパイラは型を推測する必要があるため、コンパイルのパフォーマンスコストがあると思いますが、これはほとんど無視できます。

コンパイラが自動型推論を実行できる場合、パフォーマンスに問題はありません。これらは両方とも同じコードを生成します

var    x = new ClassA();
ClassA x = new ClassA();

ただし、型を動的に構築する場合（LINQ ...）varは唯一の質問であり、ペナルティとは何かを比較するために比較する他のメカニズムがあります。

私は常にウェブ記事やガイドの文章でvarという言葉を使用しています。

オンライン記事のテキストエディターの横幅が狭いです。

これを書けば：

SomeCoolNameSpace.SomeCoolClassName.SomeCoolSubClassName coolClass = new SomeCoolNameSpace.SomeCoolClassName.SomeCoolSubClassName();

上記のレンダリングされたプリコードテキストが長すぎてボックスから流れ出し、非表示になることがわかります。完全な構文を表示するには、リーダーを右にスクロールする必要があります。

そのため、ウェブ記事の執筆では常にvarというキーワードを使用しています。

var coolClass = new SomeCoolNameSpace.SomeCoolClassName.SomeCoolSubClassName();

レンダリングされたプレコード全体が画面にぴったり収まります。

実際には、オブジェクトを宣言するためにvarを使用することはめったになく、オブジェクトをより速く宣言するためにインテリセンスに依存しています。

例：

SomeCoolNamespace.SomeCoolObject coolObject = new SomeCoolNamespace.SomeCoolObject();

しかし、メソッドからオブジェクトを返すために、私はvarを使用してより速くコードを記述しています。

例：

var coolObject = GetCoolObject(param1, param2);

"var"は、人々が愛したり嫌ったりするものの1つです（地域など）。ただし、リージョンとは異なり、匿名クラスを作成するときにはvarが絶対に必要です。

私にとって、varは次のようにオブジェクトを直接更新するときに意味があります。

var dict = new Dictionary<string, string>();

そうは言っても、簡単に行うことができます：

Dictionary<string, string> dict = newおよびintellisenseが残りの部分をここに入力します。

特定のインターフェイスのみを操作する場合は、呼び出すメソッドが直接インターフェイスを返さない限り、varを使用できません。

Resharperは、「var」を全体的に使用する側にいるようです。そのため、より多くの人々にそうするように強いられる可能性があります。しかし、メソッドを呼び出している場合は読みづらく、名前によって何が返されるのかが明確ではないことにも同意します。

var自体は速度を落とすことはありませんが、多くの人が考えていないことの1つ注意点があります。その場合はvar result = SomeMethod();、その後のコードでは、さまざまなメソッドやプロパティを呼び出すか、どんな思い結果背中のいくつかの並べ替えを期待しています。場合はSomeMethod()他のいくつかのタイプに、その定義を変更したが、それはまだ他のコードを期待していた契約に会った、あなただけ（無単位/統合テストであれば、当然の）本当に厄介なバグを作成しました。

それは状況に依存します、あなたが使用しようとすると、このコードは怒鳴ります。

表現が「OBJECT」に変換され、パフォーマンスが大幅に低下しますが、それは孤立した問題です。

コード：

public class Fruta
{
    dynamic _instance;

    public Fruta(dynamic obj)
    {
        _instance = obj;
    }

    public dynamic GetInstance()
    {
        return _instance;
    }
}

public class Manga
{
    public int MyProperty { get; set; }
    public int MyProperty1 { get; set; }
    public int MyProperty2 { get; set; }
    public int MyProperty3 { get; set; }
}

public class Pera
{
    public int MyProperty { get; set; }
    public int MyProperty1 { get; set; }
    public int MyProperty2 { get; set; }
}

public class Executa
{
    public string Exec(int count, int value)
    {
        int x = 0;
        Random random = new Random();
        Stopwatch time = new Stopwatch();
        time.Start();

        while (x < count)
        {
            if (value == 0)
            {
                var obj = new Pera();
            }
            else if (value == 1)
            {
                Pera obj = new Pera();
            }
            else if (value == 2)
            {
                var obj = new Banana();
            }
            else if (value == 3)
            {
                var obj = (0 == random.Next(0, 1) ? new Fruta(new Manga()).GetInstance() : new Fruta(new Pera()).GetInstance());
            }
            else
            {
                Banana obj = new Banana();
            }

            x++;
        }

        time.Stop();
        return time.Elapsed.ToString();
    }

    public void ExecManga()
    {
        var obj = new Fruta(new Manga()).GetInstance();
        Manga obj2 = obj;
    }

    public void ExecPera()
    {
        var obj = new Fruta(new Pera()).GetInstance();
        Pera obj2 = obj;
    }
}

上記のILSPYの結果。

public string Exec(int count, int value)
{
    int x = 0;
    Random random = new Random();
    Stopwatch time = new Stopwatch();
    time.Start();

    for (; x < count; x++)
    {
        switch (value)
        {
            case 0:
                {
                    Pera obj5 = new Pera();
                    break;
                }
            case 1:
                {
                    Pera obj4 = new Pera();
                    break;
                }
            case 2:
                {
                    Banana obj3 = default(Banana);
                    break;
                }
            case 3:
                {
                    object obj2 = (random.Next(0, 1) == 0) ? new Fruta(new Manga()).GetInstance() : new Fruta(new Pera()).GetInstance();
                    break;
                }
            default:
                {
                    Banana obj = default(Banana);
                    break;
                }
        }
    }
time.Stop();
return time.Elapsed.ToString();
}

このコードを実行したい場合は、以下のコードを使用して、時間の差を取得してください。

        static void Main(string[] args)
    {
        Executa exec = new Executa();            
        int x = 0;
        int times = 4;
        int count = 100000000;
        int[] intanceType = new int[4] { 0, 1, 2, 3 };

        while(x < times)
        {                
            Parallel.For(0, intanceType.Length, (i) => {
                Console.WriteLine($"Tentativa:{x} Tipo de Instancia: {intanceType[i]} Tempo Execução: {exec.Exec(count, intanceType[i])}");
            });
            x++;
        }

        Console.ReadLine();
    }

よろしく