Adlandırma sorunları: “Bir şeyler”, “Bir şeyler” olarak yeniden adlandırılmalı mıdır? [kapalı]

Bob Amca'nın Temiz Koddaki isimler hakkındaki bölümü , çoğunlukla Macarca notaları ile ilgili olan isimlerdeki kodlamalardan kaçınmanızı önerir. Ayrıca Iöneki arayüzlerden kaldırmayı da belirtiyor , ancak bunun örneklerini göstermiyor.

Aşağıdakileri varsayalım:

• Arayüz kullanımı temel olarak bağımlılık enjeksiyonuyla test edilebilirliği sağlamaktır.
• Çoğu durumda, bu tek bir uygulayıcı ile tek bir arayüze sahip olmasına yol açmaktadır.

Mesela, bu ikisinin adı ne olmalı? Parserve ConcreteParser? Parserve ParserImplementation?

public interface IParser {
    string Parse(string content);
    string Parse(FileInfo path);
}

public class Parser : IParser {
     // Implementations
}

Yoksa böyle tek uygulamalu davalarda bu öneriyi göz ardı etmeli miyim?

"Bob Amca" dahil birçok kişi Iarayüzler için önek olarak kullanılmamasını tavsiye ederken , bunu yapmak C # ile köklü bir gelenektir. Genel anlamda, kaçınılması gerekir. Fakat eğer C # yazıyorsanız, gerçekten o dilin kurallarını takip etmeli ve kullanmalısınız. Bunu yapmamak, kodunuzu okumayı deneyen C # ile aşina olan başka biriyle büyük bir karışıklığa neden olacaktır.

Arayüz önemli bir mantıksal kavramdır, bu yüzden arayüz genel adı taşımalıdır. Yani, tercih ederim

interface Something
class DefaultSomething : Something
class MockSomething : Something

göre

interface ISomething
class Something : ISomething
class MockSomething : ISomething

İkincisi birkaç isues vardır:

1. Bir şey, ISomething'in yalnızca bir uygulamasıdır, ancak bir şekilde özelmiş gibi, genel adı olan addır.
2. MockSomething, bir şeyden kaynaklanıyor gibi görünmekte ancak ISomething'i uygulamaktadır. Belki MockIS'e bir şey denir, ama bunu vahşi doğada hiç görmedim.
3. Yeniden düzenleme daha zordur. Something şimdi bir sınıfsa ve daha sonra bir arayüz tanıtmanız gerektiğini öğrenirseniz, bu arayüz aynı şekilde adlandırılmalıdır, çünkü türün somut bir sınıf mı, soyut bir sınıf mı yoksa bir arayüz mü olduğu istemciler için şeffaf olmalıdır. . Bir şey bunu kırar.

Bu sadece konvansiyonları adlandırmakla ilgili değil . C #, çoklu mirası desteklememektedir, bu nedenle, Macar gösteriminin bu eski kullanımının, bir temel sınıftan miras aldığınız ve bir veya daha fazla arabirim uyguladığınız yerde, küçük bir faydalı yararı vardır. Yani bu ...

class Foo : BarB, IBarA
{
    // Better...
}

... buna tercih edilir ...

class Foo : BarB, BarA
{
    // Dafuq?
}

IMO

Hayır hayır hayır.

Adlandırma kuralları Bob Amca fandomunuzun bir işlevi değildir. Dilin bir işlevi değildir, c # veya başka bir şekilde.

Bunlar kod tabanınızın bir işlevidir. Mağazanızın çok daha az bir ölçüde. Başka bir deyişle, kod tabanındaki ilki standardı belirler.

Sadece o zaman karar verirsiniz. Bundan sonra sadece tutarlı olun. Biri tutarsız olmaya başlarsa, nerf silahlarını alın ve tövbe edene kadar belgeleri güncelleyin.

Yeni bir kod tabanını okurken hiçbir Iönek görmezsem , dilden bağımsız olarak iyiyim. Her arayüzde bir tane görürsem, iyiyim. Bazen birini görürsem, biri ödeyecek.

Kendinizi kod üssünüz için emsal belirleme bağlamında bulursanız, şunu düşünmenizi tavsiye ederim:

Bir müşteri sınıfı olarak, neden bahsettiğimi umursamıyorum. İhtiyacım olan tek şey bir isim ve o isme karşı arayabileceğim bir şeyler listesi. Ben söylemedikçe bunlar değişmeyebilir. Ben bu kısmı KENDİ. Konuştuğum, arayüz ya da olmayan benim departmanım değil.

Bu Iisimde gizlice girerseniz , müşteri umursamıyor. Hayır Iise, müşteri umrunda değil. Konuştuğu şey somut olabilir. Olmayabilir. O aramazsa yana newher iki şekilde üzerinde hiç fark etmez. Müşteri olarak bilmiyorum. Bilmek istemiyorum

Şimdi, bu koda bakarak bir kod maymunu olarak, java'da bile, bu önemli olabilir. Sonuçta, bir uygulamayı bir arayüzde değiştirmek zorunda kalırsam bunu müşteriye söylemeden yapabilirim. Eğer bir Igelenek yoksa, yeniden adlandırmam bile. Bu sorun olabilir çünkü şimdi müşteriyi yeniden derlemek zorundayız çünkü kaynak ikiliyi önemsemiyor olsa bile. Adı hiç değiştirmediyseniz kaçırması kolay bir şey.

Belki bu senin için bir sorun değildir. Belki de değil. Öyleyse, bu bakım için iyi bir neden. Ancak, masa oyuncaklarının aşkı için, kör bir şekilde yapmamız gerektiğini iddia etmiyoruz çünkü bazı dillerde böyle yapılıyor. Ya iyi bir sebebi var ya da umursamıyorum.

Sonsuza dek onunla yaşamakla ilgili değil. Bu, her yerde 'sorunu' düzeltmeye hazır olmadığınız sürece, kod temeli hakkında kendi zihniyetinize uymayan mahrum etmemekle ilgili. İyi bir nedeniniz olmadığı sürece, tek biçimliliğe en az direnç gösterme yoluna girmemeliyim, bana uygunluk vaaz etme. Yapacak daha iyi işlerim var.

Java ile C # arasında ilgili küçük bir fark var. Java'da her üye varsayılan olarak sanaldır. C # 'da her üye varsayılan olarak mühürlenir - arayüz üyeleri hariç.

Bununla ilgili varsayımlar, rehberi etkilemektedir - Java'da, her kamu türü, Liskov'un İkame Prensibi'ne [1] uygun olarak nihai olarak kabul edilmemelidir. Yalnızca bir uygulamanız varsa, sınıfı adlandırırsınız Parser; Birden fazla uygulamaya ihtiyaç duyduğunuzu tespit ederseniz, sınıfı yalnızca aynı ada sahip bir arabirim ile değiştirir ve somut uygulamayı yeniden tanımlayıcı bir şeyle yeniden adlandırırsınız.

C # 'da ana varsayım, bir sınıf aldığınızda (isim ile başlamaz I), istediğiniz sınıftır. Dikkat edin, bu hiçbir yerde% 100 kesinliğe yakın değildir - tipik bir karşı örnek, Stream(gerçekten bir arabirim veya birkaç arabirim olması gereken) gibi sınıflar olabilir ve herkesin diğer dillerden kendi kılavuzları ve geçmişleri vardır. BaseSoyut bir sınıfı belirtmek için oldukça yaygın kullanılan sonek gibi başka istisnalar da var - tıpkı bir arayüzde olduğu gibi , türün polimorfik olması gerektiğini biliyorsunuz .

Ayrıca, arabirim soyut bir sınıfa başvurmak zorunda kalmadan, bu arabirim ile ilgili işlevsellik için I-olmayan isimden ayrılmasında hoş bir kullanılabilirlik özelliği de vardır (C # sınıfının çoklu kalıtım eksikliği nedeniyle zarar görebilir). Bu, IEnumerable<T>arayüz Enumerableolarak ve bu arayüz için geçerli olan yöntemlerin bir deposu olarak kullanılan LINQ tarafından popülerleştirildi . Arayüzlerin de metod uygulamaları içerebildiği Java'da bu gerekli değildir.

Sonuçta, Iönek C # dünyasında yaygın olarak kullanılır ve uzantı olarak .NET dünyası (.NET kodunun çoğu C # ile yazıldığından beri, genel arabirimlerin çoğu için C # kurallarına uymak mantıklı olur). Bu, neredeyse kesinlikle bu gösterimi izleyen kütüphaneler ve kodlarla çalışacağınız anlamına gelir ve gereksiz karışıklığı önlemek için geleneği benimsemeniz mantıklıdır - ön ekin kodunuzu daha iyi hale getireceğini ihmal etmemiz gibi değildir :)

Bob Amca'nın aklının böyle bir şey olduğunu varsayıyorum:

IBananaMuz soyut kavramdır. Bundan daha iyi bir adı olmayan herhangi bir uygulayıcı sınıf olabilirse Banana, soyutlama tamamen anlamsızdır ve arayüzü bırakıp sadece bir sınıf kullanmalısınız. Daha iyi bir ad varsa ( LongBananaveya söyle AppleBanana), Bananaarabirimin adı olarak kullanmamak için hiçbir neden yoktur . Bu nedenle, Iön ekin kullanılması, kodun faydasız bir şekilde anlaşılmasını zorlaştıran işe yaramaz bir soyutlamanız anlamına gelir. Ve katı OOP her zaman arayüzlere karşı size kod koyacağına göre I, bir türü öneki görmeyeceğiniz tek yer bir yapıcı olacaktır - oldukça anlamsız gürültü.

Bunu örnek IParserarayüzünüze uygularsanız , soyutlamanın tamamen “anlamsız” bölgede olduğunu açıkça görebilirsiniz. Ya bir ayrıştırıcı (örneğin somut bir uygulaması hakkında spesifik bir şey var JsonParser, XmlParser...), ya da sadece bir sınıf kullanmalısınız. "Varsayılan uygulama" diye bir şey yoktur (bazı ortamlarda, bu gerçekten de, özellikle de COM anlamındadır), ya belirli bir uygulama vardır ya da "varsayılanlar" için soyut bir sınıf ya da uzantı yöntemi istiyorsunuz. Bununla birlikte, C # 'da, kod tabanınız zaten I-prefix'i atlatmazsa, saklayın. Her zaman kodunu her gördüğünüzde zihinsel bir not alın class Something: ISomething- birileri YAGNI’yi takip etmede ve makul soyutlamalar oluşturmada çok iyi değil demektir.

[1] - Teknik olarak, bu Liskov'un makalesinde özel olarak belirtilmemiştir, ancak orijinal OOP makalesinin temellerinden biridir ve benim Liskov okumamda buna meydan okumamıştı. Daha az katı bir yorumda (çoğu OOP dilinin kullandığı dil), bu, yerine koyma amaçlı (yani son olmayan / mühürlü) bir kamu türünü kullanan herhangi bir kodun, bu tür uygun herhangi bir uygulama ile çalışması gerektiği anlamına gelir.

Mesela, bu ikisinin adı ne olmalı? Ayrıştırıcı ve ConcreteParser? Ayrıştırıcı ve Ayrıştırıcı Uygulama?

İdeal bir dünyada, isminizi kısa elle ("Ben ...") öneklememelisiniz, ancak adın bir kavramı ifade etmesine izin verin.

Bir yerde okudum (ve kaynak gösteremiyorum), bu ISOMothing konvansiyonunun bir "Dolar" sınıfına ihtiyaç duyduğunuzda bir "IDollar" kavramı tanımlamanıza yol açtığını, ancak doğru çözümün sadece "Para Birimi" olarak adlandırılan bir kavram olacağı fikrini verdim.

Başka bir deyişle, sözleşme, şeyleri adlandırma zorluğuna bir kolaylık verir ve kolaylık, incelikle yanlıştır .

Gerçek dünyada, kodunuzun müşterileri (sadece "gelecekten gelebilecek" olabilir) daha sonra okuyabilmeli ve mümkün olduğu kadar çabuk (veya az çabayla) tanıyabilmeli (müşterilere verebilmeli) Kodunuzun ne elde etmeyi umdukları)

Bir şey kongre, kaba / kötü isimleri tanıtır. Bununla birlikte, kodun yazılmasında kullanılan kurallar ve uygulamalar artık gerçek olmadıkça, işlenmemişlik gerçek bir sorun değildir *); Eğer sözleşme "bir şey kullan" diyorsa, o zaman kullanmak en iyisidir, diğer aygıtlara uymak (ve daha iyi çalışmak).

*) Bu acımasız "kabadayılık" ın zaten kesin bir kavram olmadığını söyleyerek kaçabilirim :)

Diğer cevapların da belirttiği gibi, arayüz adlarınızı öneklemek I, .NET framework kodlama kurallarının bir parçasıdır. Somut sınıflar, C # ve VB.NET'teki genel arayüzlerden daha sık etkileşimde oldukları için, şema adlandırmada birinci sınıftır ve bu nedenle en basit adlara sahip olmalıdır - bu nedenle IParserarayüz ve Parservarsayılan uygulama için.

Ancak, Java ve benzeri dillerde, sınıflar yerine arayüzlerin tercih edildiği durumlarda, Bob Amca, haklarının Ikaldırılması ve arayüzlerin en basit isimlere sahip olması gerektiği gibi - Parserayrıştırıcı arayüzünüz için. Ancak ParserDefaultsınıfın, rol benzeri bir ad yerine , ayrıştırıcının nasıl uygulandığını açıklayan bir adı olması gerekir :

public interface Parser{
}

public class RegexParser implements Parser {
    // parses using regular expressions
}

public class RecursiveParser implements Parser {
    // parses using a recursive call structure
}

public class MockParser implements Parser {
    // BSes the parsing methods so you can get your tests working
}

Bu, nasıl mesela olup Set<T>, HashSet<T>ve TreeSet<T>adlandırılır.

Bu I = arabirim kuralının (yeni) kuralları ihlal ettiği konusunda haklısın.

Eski günlerde, intCounter boolFlag vb. Türleriyle her şeyi ön eklerdiniz.

Önek olmadan işleri adlandırmak, ancak 'ConcreteParser' kullanmaktan da kaçınmak istiyorsanız ad alanlarını kullanabilirsiniz.

namespace myapp.Interfaces
{
    public interface Parser {...
}


namespace myapp.Parsers
{
    public class Parser : myapp.Interfaces.Parser {...
}