Normalde bir sınıfın bölgelerini nasıl düzenlersiniz?

Bir sınıfın bölgelerini düzenlemek için bir standart olup olmadığını merak ediyordum.

Şu anda kullanıyorum

Fields
Constructor
Properties
Public Methods
Private Methods

FieldsÖzel Mülkler ve Propertieskamu mülkleri olmak. Gerekirse normalde bunun içinde alt bölgeler kullanacağım veya bazen aşağıda başka bölgeler de ekleyeceğim (arayüz veya baseClass üyeleri gibi).

Sınıfla İlgili Numaralandırmalar veya zaman zaman yapılandırmalar / saf veri sınıfları (gerçek sınıf tanımının üstünde)

--- Sınıf tanımı ---

Özel üyeler

Dilde DTOR'lar varsa CTOR'lar / DTOR'lar

Genel mülkler

Fayda yöntemleri (küçük kapsamlı özel veya korumalı yöntemler)

Sınıf işlevselliği (Sınıfın kapsamına bağlı olarak birden fazla bölgeye ayrılabilir).

Alt Bölgeler? Sınıfınızın Tek Sorumluluğu var mı? (bunun üstü kapalı ... benim cevabım "Nadiren herhangi bir bölge, belki de özellikleri, yapıcıları ve yöntemleri gruplamak" ... ama o zaman bile, bu kadar kullanmıyorum)

Sadece genel olarak sınıf düzeni değil, "#regions" demek istediğinizi onaylamak istedim.

Kimsenin bölgeleri kullanmaktan bahsetmediğinden şaşırdım. OP'nin bölgeleri yerleştirmek için bir anket yapmak istediğini anlıyorum, ancak alternatif bir bakış açısı geliştirmek istiyorum.

Bölgelerden kaçınırım. Birlikte çalıştığım kodu görmeyi seviyorum. Aradığınızı bulmakta zorlanıyorsanız, kod katlama kullanın ve benzer sınıf yapılarını birlikte gruplandırın.

Neden bölgelerden nefret ediyorum? CTRL+M,Lve CTRL+M,Okod katlama arasında geçiş yapar. Ancak, çöktüğünde tüm bölgeyi gizler. Sadece yöntemleri / özellikleri / yorumları daraltmam gerekiyor.

Çok fazla bölge varsa, belki bir kod kokusu ve sınıfınız çok fazla iş yapıyor. Jeff Atwood, okumaya değer bölgeler hakkında iyi bir yazı sunuyor .

#Regions'daki favori teklifim:

Hayır, #regions kullanmayacağım. Ve hayır, TERÖRLERLE MÜZAKERE ETMİYORUM. Kapa çeneni.

- Jeff Atwood

Bununla birlikte, birçok programcının bunları kullanmakta ısrar ettiğini biliyorum. Bu soru özneldir. Sadece bir alternatif sunacağımı düşünmüştüm.

Dilden dile değişir. Ben bir Delphi kodlayıcı olduğum için, aşağıdaki gibi görünen Delphi standart kuralına uyma eğilimindeyim:

type
  TMyClass = class(TBaseClass)
  private
    private fields
    private methods
  protected
    protected fields
    protected methods
    protected properties
  public
    constructor(s)
    destructor
    public methods
    public properties
  end;

Okuması ve anlaması kolay bilgileri organize etmenin iyi bir yolunu buluyorum.

Onları şu şekilde düzenleme eğilimindeyim:

Public fields (usually static constants)
Constructors
Public methods
Private methods
Private fields

Kullanan bir dil kullanmadım Properties, bu yüzden bunlar düzenlenmedi. Özel yöntemleri ve alanları en altta koydum, çünkü başka biri bu dosyayı kodunda kullanıyorsa, yalnızca genel şeyler olan API ile kendilerini endişelendirmeleri gerekir. Ve bildiğim tüm metin editörleri ve hatta IDE'ler, dosyaları açarken imleci en üste ayarlar.

Bu benim için bir karar çağrısı. Bölgeleri okunabilirlik için gerektiğinde kullanıyorum.

Ayrıca, kodun geri kalanından öne çıkmaları için Visual Studio renk düzenimde (şu anda koyu kırmızı) farklı bir renk kullanıyorum.

Bir #region kullanabileceğime örnek: Çok satırlı bir XML snippet'i gerektiren bir birim testi için bir test yöntemi yazarsam, XML dizesi normal girintiyi kırar (çünkü Çirkinliği gizlemek için, onu #region içinde sararım, böylece onu daraltabilirim.

Bob Martin'in Temiz Kod kitabı 5. bölümün tamamını biçimlendirmeye ayırır. Güzel özetlemek hissediyorum birkaç önemli nokta vardır.

• Değişkenleri ve yöntemleri görünürlük ve temizliğe göre gruplandırma girişimlerinin çoğu mantıklı değil ve kodda çok gezinmenize neden oluyor.
• Birbirini dikey olarak çağıran yöntemleri tutmak, yapmanız gereken gezinme miktarını azaltır ve bir şeyler bulmayı kolaylaştırır.
• Eğer durup "bu kod parçası hangi bölgeye ait?" Diye düşünmek zorunda kalırsanız, düşünce treniniz kırılmaz. birkaç dakikada bir.
• Eşgörünüm değişkenleri genellikle az olmalı ve her yerde kullanılmalıdır, bu nedenle en kolay bulunabilecekleri sınıfın en üstünde yer alırlar. Yalnızca bir yöntem tarafından kullanılacak değişkenlerin ve bildirimlerin bu yöntemin içinde bulunması gerekir. Sadece birkaç yöntemle kullanılıyorsa, dikey olarak yakın olmalı, ancak bunları kullanan birkaç yöntemin üzerinde olmalıdır.

Kodunuzu ortak etkileşimli öğelerle dikey olarak birbirine yakın tutmak, belirli bölgeler oluşturma gereksinimini etkili bir şekilde ortadan kaldırır. Kodunuz o kadar uzunsa, bölgelerin çok fazla kod gizlemesini gerektiriyorsa, belki de bu sınıfın çok fazla yapmaya çalıştığını gösteren bir kod kokusudur. Belki de bazı işlevler bir yardımcı program sınıfına taşınabilir veya bir ataya doğru itilebilir.

Çok uzun veya çok "çirkin" olduğu için kodu "gizlemeniz" gerekiyorsa, endişelenmeniz gereken bölgelerin kullanılıp kullanılmayacağından daha büyük sorunlarınız olabilir. Şahsen onları asla kullanmam gerekmiyor ve bir başkasının kodu üzerinde çalışırken, onları her zaman yine de açmam gerektiğini buluyorum, neden rahatsız oluyorsun?

Şu anda böyle sınıflar düzen:

class types
constructors
destructor
accessors
methods
properties (where properties are present in the language)
member variables

ve ardından her bir bildirime erişim düzeyini önek olarak ekleyin (tür, bazen erişime göre gruplandır). Eskiden erişim yoluyla üst düzey gruplama yapardım, ama bir noktada, ne zaman olduğunu bilmiyorum, yukarıdakilerin yanı sıra işe yaramadı. Örneğin (şu anda kullanmak zorunda kaldığım C ++ / CLI'de: --() bunu yapabilir, bu da gruplama erişimini bozar:

public: property int SomeProperty
{
private: void set (int value) { ... }
public: int get () { ... }
}

Lunatic saçak cevap: Ben, en azından C # söz konusu olduğunda, yok. Visual Studio ve R # arasında sihirli bir şekilde herhangi bir üye veya uygulamaya gidebilir, bu yüzden bu şeyleri takıntılı bir anlamı yoktur; sadece imlecin olduğu yeri yazmaya başlayın.

Wyatt ve diğer birkaç cevap gibi ben de genellikle bölgelerin kullanımından kaçınırım. Bölgelerin bir amacı vardır; bakmak istemediğiniz kodu gizlemek için. Bir sınıfta çok fazla kod varsa bakmak istemezsiniz ve bu nedenle söz konusu kodu daraltmanıza izin vermek için çok fazla bölgeye ihtiyacınız varsa, muhtemelen sınıfta çok fazla kodunuz vardır. ReSharper, bölgeyi oluşturmadığı sürece (arayüz uygulamaları için yaptığı gibi) yeni kodun nereye yerleştirileceğine karar verirken bölgelere saygı duymaz.

Kabul edilebilir bulduğum bölgelerin tek kullanımı "kaçınılmaz olarak çirkin" kodu gizlemektir; mevcut standartlara göre dahili olarak iyi yapılandırılamayan belirli uygulama ayrıntılarıyla ilgilenen kod. Bu genellikle bir kez yazıldığında ortalama genç programcı tarafından karıştırılmaması gereken gelişmiş, ezoterik koddur. Bunlar şöyle:

• Bazı yerleşik arayüz uygulamaları (IDisposable, IConvertible, bazen IEnumerable veya IComparable olabilir, çünkü jenerik ve jenerik olmayan uygulamalar gerektirir)
• Gömülü P / Invoke externs ve ilgili yapılar.
• Finalizörler / yıkıcılar (genellikle IDisposable ile gider)
• Yönetilmeyen bellek / işaretçiler / "güvensiz" koduna bağlanır.