V jazyce C #, bych měl použít string.Empty nebo String.Empty nebo „“ intitialize řetězec?

hlasů
605

V jazyce C #, chci inicializovat řetězcovou hodnotu s prázdným řetězcem.

Jak to mám udělat? Jaký je správný způsob, a proč?

string willi = string.Empty;

nebo

string willi = String.Empty;

nebo

string willi = ;

nebo co?

Položena 04/11/2008 v 20:49
zdroj uživatelem
V jiných jazycích...                            


30 odpovědí

hlasů
13

Osobně preferuji „“, pokud není dobrý důvod, aby něco složitější.

Odpovězeno 04/11/2008 v 20:50
zdroj uživatelem

hlasů
6

Některou z výše uvedených.

Existuje mnoho, mnoho lepších věcí pontifikátu. Jako je, jakou barvu kůry vyhovuje strom nejlepší, myslím, že vágní hnědá s odlesky z melodický mechu.

Odpovězeno 04/11/2008 v 20:50
zdroj uživatelem

hlasů
2

I používat třetinu, ale další dvě první zdá méně zvláštní. Řetězec je alias na provázku, ale vidět je přes přiřazení cítí off.

Odpovězeno 04/11/2008 v 20:51
zdroj uživatelem

hlasů
1

Překladač by měl, aby byly všechny stejné v dlouhodobém horizontu. Vyberte normu tak, aby váš kód bude snadno čitelné, a držet se ho.

Odpovězeno 04/11/2008 v 20:52
zdroj uživatelem

hlasů
0

Myslím, že druhý je „správné“, ale abych byl upřímný, nemyslím si, že to bude jedno. Překladač by měl být dost chytrý na kompilaci některé z těch, přesně stejné bytecode. I use "" sám.

Odpovězeno 04/11/2008 v 20:52
zdroj uživatelem

hlasů
38

Raději bych stringse String. výběrem string.Emptyvíce než ""je otázkou výběru jedné a držet s ním. Výhodou použití string.Emptyje, že je velmi jasné, co máte na mysli, a nemáte náhodou zkopírovat non-tisknutelné znaky jako "\x003"ve vaší "".

Odpovězeno 04/11/2008 v 20:52
zdroj uživatelem

hlasů
5

I nedělá rozdíl. Posledním z nich je nejrychlejší typ ačkoli :)

Odpovězeno 04/11/2008 v 20:52
zdroj uživatelem

hlasů
12

String.Emptya string.Emptyjsou ekvivalentní. StringBCL je název třídy; stringje jeho C # alias (nebo zkratka, chcete-li). Stejně jako u Int32i int. Viz docs pro další příklady.

Pokud jde ""týče, nejsem si úplně jistý.

Osobně jsem vždy používat string.Empty.

Odpovězeno 04/11/2008 v 20:53
zdroj uživatelem

hlasů
2

Jeden z prvních dvou by bylo přijatelné pro mě. Já bych vyhnout ten poslední, protože je relativně snadné zavést chybu tím, že prostor mezi uvozovek. Tento konkrétní chyba by bylo obtížné najít pozorováním. Za předpokladu, že žádné překlepy, všichni jsou sémanticky ekvivalentní.

[UPRAVIT]

Také můžete chtít, aby vždy použít buď stringnebo Stringkonzistence, ale to je jen já.

Odpovězeno 04/11/2008 v 20:55
zdroj uživatelem

hlasů
3

stringje synonymum pro System.Stringdruh, jsou identické.

Hodnoty jsou také identické: string.Empty == String.Empty == ""

Já bych použít znaková konstanta „“ v kódu, spíše string.Emptynebo String.Empty- lépe vidět, co programátor myslel.

Mezi stringa StringMám rád malá písmena stringvíc jen proto, že jsem pracoval s Delphi pro mnoho let a Delphi stylu je malá string.

Takže, když jsem byl váš šéf, měli byste být psaní string.Empty

Odpovězeno 04/11/2008 v 21:00
zdroj uživatelem

hlasů
3

Nezáleží na tom, - jsou to přesně to samé. Nicméně hlavní věc je, že musí být v souladu

ps jsem bojovat s tímto druhem „co je správná věc“ po celou dobu.

Odpovězeno 04/11/2008 v 21:01
zdroj uživatelem

hlasů
67

Nejlepší kód není kód vůbec :

Základní charakter kódování je, že naším úkolem, jako programátoři, je si uvědomit, že každé rozhodnutí děláme je trade-off. [...] Začněte s stručnost. Zvyšovat ostatní rozměry dle požadavků testování.

V důsledku toho je méně kód je lepší kód: Preferuji "", aby string.Emptyči String.Empty. Ti dva jsou šestkrát déle bez přidaného výhodu - rozhodně ne přidal jasnost, protože vyjadřují stejné informace.

Odpovězeno 04/11/2008 v 21:04
zdroj uživatelem

hlasů
18

Neměl jsem v úmyslu, aby vyzváněl, ale já jsem viděl některé špatné info dostat vyhodili zde.

Já osobně nejraději string.Empty. Je to osobní preference, a já se ohýbat k vůli cokoli tým pracuji se případ od případu.

Jak již bylo zmíněno některé další, není žádný rozdíl mezi vůbec string.Emptya String.Empty.

Navíc, a to je málo známý fakt, pomocí tlačítka „“ je naprosto přijatelné. Každá instance „“ bude v jiném prostředí, vytvořit objekt. Nicméně, .NET internuje jeho řetězce, takže budoucí případy bude tahat stejnou neměnnou řetězec od internovat bazénu, a nějaký výkon hit bude zanedbatelný. Zdroj: Brad Abrams .

Odpovězeno 04/11/2008 v 21:07
zdroj uživatelem

hlasů
702

Použijte cokoliv vy a váš tým najít nejvíce čitelný.

Jiné odpovědi naznačují, že nový řetězec je vytvořen při každém použití "". To není pravda - z důvodu řetězec internovat, bude vytvořena buď jednou za montáž nebo jednou za AppDomain (nebo možná jednou za celý proces - a to jistě na tomto poli). Tento rozdíl je zanedbatelný - masivně, masivně nevýznamné.

Který najdete lepší čitelnost je jiná věc, nicméně. Je to subjektivní a bude lišit od člověka k člověku - takže navrhuji, abyste zjistili, co většina lidí ve svém týmu rád, a všichni jdou s tím konzistence. Osobně považuji ""čitelnější.

Argument, že ""a " "jsou snadno zaměněny za sebe opravdu není umýt se mnou. Pokud používáte proporcionální písmo (a já jsem pracoval s jakýmikoli vývojáři, kteří dělají), je to docela snadné poznat rozdíl.

Odpovězeno 04/11/2008 v 21:07
zdroj uživatelem

hlasů
-1

Zatímco rozdíl je velmi, velmi malý rozdíl stále existují.

1) „“ vytváří objekt, zatímco String.Empty není. Ale tento objekt bude vytvořen pouze jednou a bude odkazováno z řetězce bazénu později, pokud máte jiný „“ v kódu.

2) String a řetězec jsou stejné, ale já bych doporučit používat String.Empty (stejně jako String.Format, String.Copy atd.), Protože dot notace označuje třídu, nikoliv provozovatele, a která má třídu počínaje velké písmeno odpovídá C # standardů kódování.

Odpovězeno 05/11/2008 v 08:12
zdroj uživatelem

hlasů
5

I silně přednost String.Empty, stranou od ostatních důvodů, aby vám vědět, co to je, a že jste omylem odstranili obsah, ale především pro oblast mezinárodního obchodu. Když vidím řetězec v uvozovkách pak jsem vždycky zajímalo, zda se jedná o nový kód a měl by být uveden do tabulky řetězců. Takže pokaždé, když kód dostane změnil / hodnotilo budete muset hledat pro „něco v uvozovkách“ a ano, můžete odfiltrovat prázdné řetězce, ale říkám lidem, že je dobrým zvykem nikdy dát řetězce v uvozovkách, pokud víte, že to nebude mít lokalizované ,

Odpovězeno 22/01/2009 v 18:03
zdroj uživatelem

hlasů
10

Jen asi každý vývojář tam bude vědět, co „“ prostředků. Já osobně setkal String.Empty poprvé a musel strávit nějaký čas hledáním google, aby zjistili, zda skutečně jsou přesně to samé.

Odpovězeno 31/05/2009 v 20:34
zdroj uživatelem

hlasů
353

Tam opravdu není žádný rozdíl od výkonu a kódu generovaného hlediska. Při testování výkonnosti, šli tam a zpět mezi nichž jedna byla rychlejší vs jiný, a to pouze milisekund.

Při pohledu na jednání za kódem scén, opravdu nevidím žádný rozdíl, ať. Jediný rozdíl je v IL, který string.Emptypoužívat operační kód ldsfld a ""používá operační kód ldstr, ale to je jen proto, že string.Emptyje statická, a obě instrukce dělat totéž. Když se podíváte na sestavu, která je vyrábí, je to přesně to samé.

C # Code

private void Test1()
{
    string test1 = string.Empty;    
    string test11 = test1;
}

private void Test2()
{
    string test2 = "";    
    string test22 = test2;
}

IL Code

.method private hidebysig instance void 
          Test1() cil managed
{
  // Code size       10 (0xa)
  .maxstack  1
  .locals init ([0] string test1,
                [1] string test11)
  IL_0000:  nop
  IL_0001:  ldsfld     string [mscorlib]System.String::Empty
  IL_0006:  stloc.0
  IL_0007:  ldloc.0
  IL_0008:  stloc.1
  IL_0009:  ret
} // end of method Form1::Test1
.method private hidebysig instance void 
        Test2() cil managed
{
  // Code size       10 (0xa)
  .maxstack  1
  .locals init ([0] string test2,
                [1] string test22)
  IL_0000:  nop
  IL_0001:  ldstr      ""
  IL_0006:  stloc.0
  IL_0007:  ldloc.0
  IL_0008:  stloc.1
  IL_0009:  ret
} // end of method Form1::Test2

kód Assembly

        string test1 = string.Empty;
0000003a  mov         eax,dword ptr ds:[022A102Ch] 
0000003f  mov         dword ptr [ebp-40h],eax 

        string test11 = test1;
00000042  mov         eax,dword ptr [ebp-40h] 
00000045  mov         dword ptr [ebp-44h],eax 
        string test2 = "";
0000003a  mov         eax,dword ptr ds:[022A202Ch] 
00000040  mov         dword ptr [ebp-40h],eax 

        string test22 = test2;
00000043  mov         eax,dword ptr [ebp-40h] 
00000046  mov         dword ptr [ebp-44h],eax 
Odpovězeno 19/10/2009 v 14:31
zdroj uživatelem

hlasů
2

Je zcela preference code-style, dělat s tím, jak NET zpracovává řetězce. Nicméně, zde jsou mé názory :)

Při přístupu statické metody, vlastnosti a pole I vždy používat názvy BCL Typ: String.Emptynebo Int32.TryParse(...)neboDouble.Epsilon

Vždycky jsem použít C # klíčová slova při ohlášení nových instancí: int i = 0;nebostring foo = "bar";

I zřídka používají nedeklarované řetězcové literály, jak jsem chtěl, aby bylo možné kontrolovat kód zkombinovat do recyklovatelných pojmenované konstanty. Kompilátor nahradí konstanty s literalu tak jako tak, takže je to spíše tak, aby se zabránilo magické provazy / čísla a dát trochu větší význam pro ně s názvem. Plus změnou hodnot je snazší.

Odpovězeno 31/08/2010 v 22:52
zdroj uživatelem

hlasů
45

Jeden rozdíl je, že pokud použijete switch-casesyntaxi, nelze zapisovat case string.Empty:, protože to není konstantní. ZískáteCompilation error : A constant value is expected

Podívejte se na tento odkaz pro více informací: řetězec prázdný versus prázdné uvozovky

Odpovězeno 26/08/2011 v 09:58
zdroj uživatelem

hlasů
0

On http://blogs.msdn.com/b/brada/archive/2003/04/22/49997.aspx :

Jako David vyplývá, že rozdíl mezi String.Emptya ""jsou docela malé, ale tam je rozdíl. ""ve skutečnosti vytvoří objekt, bude pravděpodobně možné vytáhnout ze řetězec internovat bazénu, ale přesto ... a zároveň String.Emptyvytváří žádný objekt ... takže pokud jste opravdu hledali nakonec účinnosti paměti, navrhuji String.Empty. Nicméně, měli byste mít na paměti, je rozdíl, takže se vám bude líbit trival nikdy vidět v kódu ...
Co se týče System.String.Emptyči string.Emptynebo String.Empty... mou úroveň péče je nízká ;-)

Odpovězeno 16/11/2011 v 03:28
zdroj uživatelem

hlasů
5

Nikdo se zmínil, že v VisualStudio String je zbarvena jinak pak řetězec. Což je důležité pro čitelnost. Také malá písmena se obvykle používá pro Vars a typ, není velký problém, ale String.Empty je konstantní a ne var nebo typ.

Odpovězeno 24/05/2012 v 17:16
zdroj uživatelem

hlasů
2

I by dala přednost string.Emptypřes String.Emptyprotože jej můžete použít, aniž by musel obsahovat using System;ve svém souboru.

Pokud jde o vybírání ""nad string.Empty, to je osobní preference a mělo by být rozhodnuto svého týmu.

Odpovězeno 10/06/2015 v 14:13
zdroj uživatelem

hlasů
7

Toto téma je docela starý a dlouho, takže mě omluvte, pokud toto chování bylo uvedeno někde jinde. (A místo mě k odpovědi, která pokrývá to)

Zjistil jsem, že rozdíl v chování kompilátor, pokud používáte string.Emptynebo uvozovek. Rozdíl se projevuje, pokud nepoužijete proměnnou řetězce inicializace s string.Empty nebo uvozovek.

V případě inicializace se string.Emptypak kompilátor varování

CS0219 - The variable 'x' is assigned but its value is never used

nikdy emitováno, zatímco v případě inicializace s uvozovek dostanete očekávanou zprávu.

Toto chování je vysvětlena v článku Connect na tomto odkazu: https://connect.microsoft.com/VisualStudio/feedback/details/799810/c-warning-cs0219-not-reported-when-assign-non-constant-value

V podstatě, když jsem si to pravé, že chtějí, aby programátor nastavit proměnnou s návratovou hodnotu funkce pro účely ladění, aniž by se obtěžoval ho s varovným hlášením, a proto se omezil upozornění pouze v případě úkolů costant a řetězec. prázdná není konstantní, ale pole.

Odpovězeno 29/04/2016 v 21:09
zdroj uživatelem

hlasů
7

Provedl jsem tento velmi jednoduchý test s použitím následující funkce v aplikace konzoly:

private static void CompareStringConstants()
{
    string str1 = "";
    string str2 = string.Empty;
    string str3 = String.Empty;
    Console.WriteLine(object.ReferenceEquals(str1, str2)); //prints True
    Console.WriteLine(object.ReferenceEquals(str2, str3)); //prints True
}

To jasně ukazuje, že všechny tři proměnné a to str1, str2i str3když se inicializuje pomocí různých syntaxe, ale směřují do přesně stejného řetězce (o délce nula) objektu v paměti. Provedl jsem tento test v .Net 4.5 konzoly aplikací. Tak vnitřně nemají žádný rozdíl, a to všechno se scvrkává na komfort, který z nich chcete použít jako programátor. Toto chování strun třídy je znám jako řetězec internovat v .Net. Eric Lippert má velmi pěkný blog zde popisující tuto koncepci.

Odpovězeno 12/10/2016 v 12:37
zdroj uživatelem

hlasů
1

Jen jsem se díval na nějaký kód a tuto otázku odebere do mé mysli, které jsem předtím četl nějaký čas. To je jistě otázka čitelnosti.

Vezměme si následující kód C #, ...

(customer == null) ? "" : customer.Name

proti

(customer == null) ? string.empty : customer.Name

Já osobně najít druhá méně nejednoznačný a čitelnější.

Jak již bylo uvedeno ostatními skutečné rozdíly jsou zanedbatelné.

Odpovězeno 10/01/2017 v 16:11
zdroj uživatelem

hlasů
1

Osobně jsem byl svědkem „“ končit (menší) problémy dvakrát. Poté, co bylo způsobeno chybou junior vývojáře nových programů do týmové systémem, a druhý byl jednoduchý překlep, ale skutečnost je pomocí string.Empty by se vyhnout obě otázky.

Ano, to je do značné míry úsudku, ale když jazyk poskytuje několik způsobů, jak dělat věci, mám tendenci se přiklánět k jedné, která má největší kompilátoru dohledu a nejsilnější výkonu v době kompilace. To není „“. Je to všechno o vyjádření konkrétní záměr.

Pokud zadáte string.EMpty nebo Strng.Empty, překladač vám vědět, jste udělali špatně. Ihned. To prostě nebude sestavovat. Jako vývojář se citovat konkrétní záměr, že překladač (nebo jiný developer) nemůže v žádném případě dezinterpretaci, a když to uděláte špatně, nelze vytvořit chybu.

Zadáte-li „“, když máte na mysli „“ nebo naopak, kompilátor šťastně dělá to, co jste to řekl dělat. Další developer může nebo nemusí být schopen sbírat vaše konkrétní záměr. Bug vytvořili.

Dlouho předtím, než string.Empty to věc, kterou jsem použil standardní knihovny, které definovaly EMPTY_STRING konstantu. Stále používáme, že konstanta v případě prohlášení, kde se string.Empty není povoleno.

Kdykoliv je to možné, dát kompilátor pracovat pro vás, a vyloučit možnost lidské chyby, bez ohledu na to, jak malý. IMO, to přebíjí „čitelnost“ jako jiní citovaný.

Specifičnost a výkon v čase kompilace. To je to, co je k večeři.

Odpovězeno 18/05/2017 v 15:44
zdroj uživatelem

hlasů
1

I use „“, protože to bude barevný výrazně žlutě v mém kódu ... z nějakého důvodu String.Empty je celý bílý v mém Visual Studio téma kód. A věřím, že mi záleží nejvíce.

Odpovězeno 24/05/2017 v 17:14
zdroj uživatelem

hlasů
0

Prázdný řetězec je jako prázdné množině jen jméno, které každý používá k volání "". Také ve formálních jazyků struny vytvořené z abecedy, které mají nulovou délku se nazývá prázdný řetězec. Oba set a string mají speciální symbol pro něj. Prázdný řetězec: ε a prázdná množina: ∅. Chcete-li mluvit o této nulové délky řetězce budete říkat prázdný řetězec, takže každý ví přesně, co máte na mysli. Nyní v případě, že si vzpomenete na prázdný řetězec proč nepoužít string.Emptyv kódu, jeho ukazuje, že záměrem je explicitní. Nevýhodou je, že to není konstantní, a proto není k dispozici všude, stejně jako v atributech. (To není konstantní pro některé z technických důvodů, viz referenční zdroj.)

Odpovězeno 10/12/2017 v 19:44
zdroj uživatelem

hlasů
0

Dávám přednost "", protože je kratší a String.Emptyřeší problém, který neexistuje.

Odpovězeno 27/11/2019 v 15:29
zdroj uživatelem

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more