ReSharper memperingatkan: "Bidang statis dalam tipe generik"

public class EnumRouteConstraint<T> : IRouteConstraint
    where T : struct
{
    private static readonly Lazy<HashSet<string>> _enumNames; // <--

    static EnumRouteConstraint()
    {
        if (!typeof(T).IsEnum)
        {
            throw new ArgumentException(
                Resources.Error.EnumRouteConstraint.FormatWith(typeof(T).FullName));
        }

        string[] names = Enum.GetNames(typeof(T));
        _enumNames = new Lazy<HashSet<string>>(() => new HashSet<string>
        (
            names.Select(name => name), StringComparer.InvariantCultureIgnoreCase
        ));
    }

    public bool Match(HttpContextBase httpContext, Route route, 
                        string parameterName, RouteValueDictionary values, 
                        RouteDirection routeDirection)
    {
        bool match = _enumNames.Value.Contains(values[parameterName].ToString());
        return match;
    }
}

Apakah ini salah? Saya akan berasumsi bahwa ini sebenarnya memiliki static readonlybidang untuk setiap kemungkinan EnumRouteConstraint<T>yang kebetulan saya contoh.

Tidak masalah untuk memiliki bidang statis dalam tipe generik, selama Anda tahu bahwa Anda benar-benar akan mendapatkan satu bidang per kombinasi argumen tipe. Dugaan saya adalah bahwa R # hanya memperingatkan Anda jika Anda tidak menyadarinya.

Berikut ini contohnya:

using System;

public class Generic<T>
{
    // Of course we wouldn't normally have public fields, but...
    public static int Foo;
}

public class Test
{
    public static void Main()
    {
        Generic<string>.Foo = 20;
        Generic<object>.Foo = 10;
        Console.WriteLine(Generic<string>.Foo); // 20
    }
}

Seperti yang Anda lihat, Generic<string>.Fooadalah bidang yang berbeda dari Generic<object>.Foo- mereka memegang nilai yang terpisah.

Dari wiki JetBrains :

Dalam sebagian besar kasus, memiliki bidang statis dalam tipe generik adalah tanda kesalahan. Alasan untuk ini adalah bahwa bidang statis dalam tipe generik tidak akan dibagikan di antara contoh dari berbagai jenis konstruksi dekat. Ini berarti bahwa untuk kelas generik C<T>yang memiliki bidang statis X, nilai C<int>.Xdan C<string>.X memiliki nilai independen yang sama sekali berbeda.

Dalam kasus yang jarang terjadi ketika Anda melakukan membutuhkan 'khusus' bidang statis, jangan ragu untuk menekan peringatan.

Jika Anda perlu memiliki bidang statis dibagi antara instance dengan argumen generik yang berbeda, tentukan kelas dasar non-generik untuk menyimpan anggota statis Anda, lalu atur tipe generik Anda untuk mewarisi dari tipe ini.

Ini tidak selalu merupakan kesalahan - ini memperingatkan Anda tentang kesalahpahaman potensial dari C # generics.

Cara termudah untuk mengingat apa yang dilakukan generik adalah sebagai berikut: Generik adalah "cetak biru" untuk membuat kelas, seperti halnya kelas adalah "cetak biru" untuk membuat objek. (Yah, ini adalah penyederhanaan. Anda dapat menggunakan metode generik juga.)

Dari sudut pandang MyClassRecipe<T>ini bukan kelas - itu adalah resep, cetak biru, seperti apa kelas Anda nantinya. Setelah Anda mengganti T dengan sesuatu yang konkret, katakan int, string, dll., Anda mendapatkan kelas. Adalah sah untuk memiliki anggota statis (bidang, properti, metode) yang dideklarasikan di kelas Anda yang baru dibuat (seperti di kelas lain) dan tidak ada tanda kesalahan apa pun di sini. Akan terlihat mencurigakan, pada pandangan pertama, jika Anda mendeklarasikan static MyStaticProperty<T> Property { get; set; }dalam cetak biru kelas Anda, tetapi ini juga legal. Properti Anda akan menjadi parameter, atau juga templated.

Tidak heran dalam statika VB disebut shared. Namun dalam hal ini, Anda harus menyadari bahwa anggota yang "dibagikan" tersebut hanya dibagikan di antara instance dari kelas yang sama persis, dan tidak di antara kelas berbeda yang dihasilkan dengan mengganti <T>dengan yang lain.

Sudah ada beberapa jawaban bagus di sini, yang menjelaskan peringatan dan alasannya. Beberapa dari keadaan ini seperti memiliki medan statis dalam tipe generik umumnya kesalahan .

Saya pikir saya akan menambahkan contoh bagaimana fitur ini dapat berguna, yaitu kasus di mana menekan peringatan R # masuk akal.

Bayangkan Anda memiliki seperangkat kelas entitas yang ingin Anda buat bersambung, katakanlah ke Xml. Anda dapat membuat serializer untuk penggunaan ini new XmlSerializerFactory().CreateSerializer(typeof(SomeClass)), tetapi kemudian Anda harus membuat serializer terpisah untuk setiap jenis. Menggunakan generik, Anda bisa menggantinya dengan yang berikut ini, yang bisa Anda tempatkan di kelas generik tempat entitas dapat berasal:

new XmlSerializerFactory().CreateSerializer(typeof(T))

Karena Anda mungkin tidak ingin membuat serializer baru setiap kali Anda perlu membuat cerita bersambung dari jenis tertentu, Anda dapat menambahkan ini:

public class SerializableEntity<T>
{
    // ReSharper disable once StaticMemberInGenericType
    private static XmlSerializer _typeSpecificSerializer;

    private static XmlSerializer TypeSpecificSerializer
    {
        get
        {
            // Only create an instance the first time. In practice, 
            // that will mean once for each variation of T that is used,
            // as each will cause a new class to be created.
            if ((_typeSpecificSerializer == null))
            {
                _typeSpecificSerializer = 
                    new XmlSerializerFactory().CreateSerializer(typeof(T));
            }

            return _typeSpecificSerializer;
        }
    }

    public virtual string Serialize()
    {
        // .... prepare for serializing...

        // Access _typeSpecificSerializer via the property, 
        // and call the Serialize method, which depends on 
        // the specific type T of "this":
        TypeSpecificSerializer.Serialize(xmlWriter, this);
     }
}

Jika kelas ini TIDAK generik, maka setiap instance dari kelas akan menggunakan yang sama _typeSpecificSerializer.

Karena IS generik, satu set instance dengan tipe yang sama untuk Takan membagikan satu instance _typeSpecificSerializer(yang akan dibuat untuk tipe spesifik itu), sedangkan instance dengan tipe berbeda untuk Takan menggunakan instance berbeda dari _typeSpecificSerializer.

Sebuah contoh

Asalkan dua kelas yang memperpanjang SerializableEntity<T>:

// Note that T is MyFirstEntity
public class MyFirstEntity : SerializableEntity<MyFirstEntity>
{
    public string SomeValue { get; set; }
}

// Note that T is OtherEntity
public class OtherEntity : SerializableEntity<OtherEntity >
{
    public int OtherValue { get; set; }
}

... mari kita gunakan:

var firstInst = new MyFirstEntity{ SomeValue = "Foo" };
var secondInst = new MyFirstEntity{ SomeValue = "Bar" };

var thirdInst = new OtherEntity { OtherValue = 123 };
var fourthInst = new OtherEntity { OtherValue = 456 };

var xmlData1 = firstInst.Serialize();
var xmlData2 = secondInst.Serialize();
var xmlData3 = thirdInst.Serialize();
var xmlData4 = fourthInst.Serialize();

Dalam hal ini, di bawah tenda, firstInstdan secondInstakan menjadi instance dari kelas yang sama (yaitu SerializableEntity<MyFirstEntity>), dan dengan demikian, mereka akan berbagi instance dari _typeSpecificSerializer.

thirdInstdan fourthInstmerupakan instance dari kelas yang berbeda ( SerializableEntity<OtherEntity>), dan juga akan berbagi contoh _typeSpecificSerializeryang berbeda dari dua lainnya.

Ini berarti Anda mendapatkan instans serializer yang berbeda untuk masing-masing jenis entitas Anda , sambil tetap membuatnya statis dalam konteks masing-masing jenis aktual (yaitu, dibagikan di antara instance yang dari jenis tertentu).