๐จC# ํ๋ก๊ทธ๋๋จธ ์ค๋ฅ 7๊ฐ๐(์ ๋ฌผ)
๋น๋ก ์ด๋ฐ ์ํ์ฐฉ์ค '์ ๋ต' ์ ํจ๊ณผ๊ฐ ์์ง๋ง, ๊ฐ๋ฐ์๊ฐ ์ค๋ฅ๋ฅผ ๋ฐ๊ฒฌํ์ง ๋ชปํ๋ฉด, ๊ทธ๋ค์ ๊ฐ๋ฐ๋ ์ํํธ์จ์ด์์ ๋ง์ ํจ์จ๊ณผ ํ์ง ๋ฌธ์ ๋ฅผ ์ด๋ํ ์ ์๋ค.
๋ณธ๋ฌธ์์ ๋๋ ๋ง์ C# ๊ฐ๋ฐ์๋ค์ด ๊ฐ์ฅ ํํ๊ณ ํํ์ง ์์ ์ค๋ฅ๋ฅผ ์์งํ๋ค.
โ 1. ๋ฌธ์์ด ์ฐ๊ฒฐ ์ฌ์ฉ
๋ฌธ์์ด ์ง๋ ฌ ํจ์์ ์์ ๋ฐฉ์์ ์ดํดํ๊ธฐ ์ฝ๋ค๐
๋ฌธ์์ด์ ๋ด์ฉ์ ์ถ๊ฐํ ๋๋ง๋ค ๋ฉ๋ชจ๋ฆฌ์ ์๋์ผ๋ก ์ ์ฃผ์๋ฅผ ํ ๋นํฉ๋๋ค.์ด์ ๋ฌธ์์ด์ ๋ณ๊ฒฝ๋ ์์น๊ฐ ์๋ ์ ๋ถํ์ ๋ณต์ฌ๋ฉ๋๋ค. (์ด๊ฒ์ ๊ทผ๋ณธ์ ์ผ๋ก ํจ์จ์ ์ด์ง ์์ต๋๋ค.)ย
AspireSys์ ์๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค.๐
List dotnetsaferTools = new List(){"Shield","Secrets","Linker"};
string tools = string.Empty;
foreach (var tool in dotnetsaferTools)
{
tools += tool; // Creates a copy of the string in memory
}
โ ์๋ฃจ์
์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐฉ๋ฒ์ ๋งค์ฐ ๊ฐ๋จํฉ๋๋ค. ๋ฌธ์์ด ์งํฉ์ด ์๋ StringBuilder ๋์์ ์ฌ์ฉํด์ผ ํฉ๋๋ค. ์ด๊ฒ์ ๋ฉ๋ชจ๋ฆฌ์์ ๊ฐ์ ์์น๋ฅผ ์ ์งํ๊ณ ๋ณต์ฌ ์์ ์ ์ํํ ํ์๊ฐ ์์ต๋๋ค.
์ด๊ฒ์ ๋ฌธ์์ด ์ฐ๊ฒฐ ๊ณผ์ ์ ๋์ฑ ๊ฐ๋จํ๊ณ ํจ์จ์ ์ผ๋ก ํ๊ธฐ ๋๋ฌธ์ ์ฐ๋ฆฌ๋ ํ์ํ ๋ชจ๋ ์กฐ์์ ๋นํ์์ด ์ถ๊ฐํ ์ ์๋ค.
์ด๊ฒ ์์ ๋ชจ์ต์ด์์.๐
StringBuilder toolsBuilder = new StringBuilder();
foreach (var tool in dotnetsaferTools)
{
toolsBuilder.Append(tool);
}
โ 2. LINQ ๋์ ๊ฐ์ ์ฌ์ฉํ์ฌ ๋ฐ๋ณต
๋ชฉ๋ก์ ๋ฐ๋ณตํด์ ๊ธฐ๋กํ๋ ค๊ณ ์๋ํ ๋ ์ด ์ค๋ฅ๊ฐ ๋ฐ์ํฉ๋๋ค. ์ด๊ฒ์ ์ต์ ์ด ์๋๋๋ค.
foreach (Customer customer in CustomerList) {
if (customer.State == "ES") {
tax += customer.Balance;
}
}
โ ์๋ฃจ์
์ฐ๋ฆฌ๋ ์ด๋ ๊ฒ ํ์ง ๋ง๊ณ LINQ๋ฅผ ๊ฐ๋จํ๊ฒ ์ฌ์ฉํด์ผ ํ๋ค. LINQ๋ ์ฐ๋ฆฌ๊ฐ ์ฝ๊ฒ ๋์์ ์กฐํํ ์ ์๋๋ก ํ ๊ฒ์ด๋ค.
tax = CustomerList.Where(customer => customer.State.Equals("ES")).Sum(c=>c.Balance);
๐ This is more efficient than a foreach loop.
โ 3. ์์ต๋ฅ ์ ์ฌ์ฉํ์ง ์๋๋ค
์ด๊ฒ์ ๋ค๋ฅธ ํธ์ถ์๋ฅผ ์ํ ๋์ ๋งค๊ฑฐ์ง์ด ํ์ํ ๊ฒฝ์ฐ์ ์ ์ฉ๋ฉ๋๋ค.์ด ๊ธฐ๋ฅ์ ์ฌ์ฉํ๋ฉด ์ฑ๋ฅ์ด ํฌ๊ฒ ํฅ์๋ฉ๋๋ค.
โ ์๋ฃจ์
์ด ์ค๋ฅ๋ฅผ ํผํ๊ธฐ ์ํด์, ๋ฐํ ์ํ์๋ น์ ์๋ํด์๋ ์ ๋ฉ๋๋ค.์ฌ์ฉ ์์ต๋ฅ ์์ต์ ๊ฐ์ฅ ํฐ ์ฅ์ ์ ์ ์ฒด ์งํฉ์ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅํ ํ์๊ฐ ์๋ค๋ ๊ฒ์ด๋ค.
์ด๊ฒ์ ๋งค๋ฒ ๊ต์ฒด๋ ํ์ ์ ์ด๋ฅผ ํ ์ ์๊ณ ํ์ํ ๊ฒฐ๊ณผ๋ง ์ฒ๋ฆฌํ ์ ์์ต๋๋ค.
โ 4. LINQ ์คํ ์ง์ฐ
LINQ์ ์ฃผ์ ๊ธฐ๋ฅ ์ค ํ๋๋foreach ์ํ์ ์ฌ์ฉํ ๋ ๋ฐ์ดํฐ ์กฐํ๋ฅผ ํธ๋ฆฌํ๊ฒ ํ๋ ๊ฒ์ด๋ค. ์๋ฅผ ๋ค์ดif ๋ธ๋ก์ ๋ผ์ ๋ฃ๋ ๊ฒ์ด๋ค.ํด๋ผ์ด์ธํธ ๋ชฉ๋ก์ ๋ณด๋ ค๋ฉด LINQ To SQL์ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
public IEnumerable GetCustomers()
{
using(var context = new DBContext())
{
return from c in context.Customers
where c.Balance > 2000
select c;
}
}
๋ณด์ํ๋ ๋ชจ๋ ๊ฒ์ด ๋ค ์ข์ ๊ฒ ๊ฐ์ง ์๋?์ฐ๋ฆฌ๊ฐ ๋งค๊ฑฐ ์งํฉ์ ์๋ํ ๋๊น์ง (์ด์์ผ๋ก ๋๋์๊ฐ ๊ฒ์ด๋ค.)๊ฒฐ๊ณผ์ ์ผ๋ก LINQ๋ ๋งค๊ฑฐ์ง ๊ฒฐ๊ณผ๋ฅผ ์๋ํ๊ธฐ ์ ์ ์ด๋ ํ ์ง์๋ ์ํํ์ง ์์ต๋๋ค.
โ ์๋ฃจ์
๋ชจ๋ LINQ ์ง์๋ฅผ ToArray()๋ก ๋ณํํ๋ ๊ฐ๋จํ ์๋ฃจ์ ์ ๋๋ค.์ด๋ ๊ฒ ํ๋ฉด LINQ๋ ๋จผ์ ์กฐํ๋ฅผ ํ๊ฐํ ๋ค์์ ๋ค๋ฅธ ์ผ์ ํด์ผ ํ๋ค.
โ 5. ๊ตฌ์กฐ ํจ์์ ์ ๊ทผํ ๊ฐ์ ๊ตฌ์ฑ์
๋น๋ก ์ด๊ฒ์ ์ฒซ ๋ฒ์งธ ์ค์๋ ์๋์ง๋ง, ๊ทธ๊ฒ์ ๊ฐ์ฅ ํํ ๋ณผ ์ ์๋ ์ค์ ์ค์ ํ๋์ด๋ค. ๋น๋ก ๋ณด๊ธฐ์๋ ๊ทธ๋ ์ง ์์ ์๋ ์์ง๋ง.ย
๋ค์ ์ฐ๋ ๋ฐฉ๋ฒ์ด ๊ธฐ๋ณธ ํด๋์ค์ ๊ตฌ์กฐ ํจ์์์ ์ง์ ํธ์ถ๋ ๋, ์ด ์ค๋ฅ๋ ๋ฏธ๋ฆฌ ์คํ๋ ์ฝ๋์์ ๋ฐ์ํ๊ธฐ ๋๋ฌธ์ ๋๋ค.
public class Parent
{
public Parent()
{
Console.WriteLine("Parent Ctor");
Method();
}
public virtual void Method()
{
Console.WriteLine("Parent method");
}
}
public class Child : Parent
{
public Child()
{
Console.WriteLine("Child Ctor");
}
public override void Method()
{
Console.WriteLine("Child method");
}
}
โ ์๋ฃจ์
๋ณต์กํด ๋ณด์ด์ง๋ง ์ฌ์ค์ ๊ฐ๋จํด์.์ฐ๋ฆฌ๋ ๋จ์ง ์ด ์ข ๋ฅ๋ฅผ ๋ฐ๋ด์ผ๋ก ํ์ํ ๋ฟ์ด๋ค.
What does this do? ๐ค
์ด๋ ๊ฒ ํจ์ผ๋ก์จ, ์ฐ๋ฆฌ๋ ๊ฐ์ ๋ฐฉ๋ฒ์ ํธ์ถํ ๋ ์ด๋ ํ ๊ฒฝ๊ณ ๋ ๋ฐ์ง ์๋๋ก ํ๋ณดํ๋ค.
โ 6. ๋ฌผํ ์ฒ๋ฆฌ์ ์ค์์ฑ ๋ชฐ๋ผ
ํ์ฒดํฌ๋ก์nl์ ๋ง์ C# ๊ฐ๋ฐ์๋ค์ด ์ด๋ฌํ ๊ฐ๋ , ์ฆ using ํค์๋๋ฅผ ๋ช ์นญ ๊ณต๊ฐ์ ์ถ๊ฐํ๋ ์ง๋ น์ผ๋ก ์ฌ์ฉํ ๋ฟ๋ง ์๋๋ผ ๋์ ์ญ์ ์๋ ๋งค์ฐ ์ ์ตํ๋ค๊ณ ๋งํ๋ค.
โ ์๋ฃจ์
์ด๋ค ์์ ์ ์ํํ ๋ ๋์์ ์ญ์ ํด์ผ ํ๋ค๊ณ ํ์ ํ๋ค๋ฉด, ๊ทธ ๋์์ด ์ ํํ๊ฒ ์ญ์ ๋์๋์ง ํ์ธํ๋ ค๋ฉด using ๋ฌธ๊ตฌ๋ฅผ ์ฌ์ฉํ์ญ์์ค.
์๋ฅผ ํ๋ ๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.๐
using(DisposableClass DisposableObject = new DisposableClass())
{
DisposableObject.DoTheJob();
}
// Does the same as:
DisposableClass DisposableObject = new DisposableClass();
try
{
DisposableObject.DoTheJob();
}
finally
{
DisposableObject.Dispose();
}
โ 7. ์ฝํ ์ํธํ ์๊ณ ๋ฆฌ์ฆ ์ฌ์ฉ
์ฌ๊ธฐ์, ์ฐ๋ฆฌ๋ Stackify์ ๊ด์ ์ ๋์ํ๋ค. ์ด ์ค๋ฅ๋ ๋จ์ง ๋ง์ ๊ฐ๋ฐ์๋ค์ด ์ ํ์ด ์ง๋ฌ๊ฑฐ๋ ๊ณต๊ฒฉ๋ฐ๊ธฐ ์ฌ์ด ์ํธํ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ด๋ค. (์ด๊ฒ์ ํผํ๊ธฐ ์ฝ๋ค.)
์ด ์์์ SHA1์ด๋ RIPEMD160๊ณผ ๊ฐ์ ๊ฒ์ ํ์ฌ์ ๋งค์ฐ ์ข์ ์์ ์์ค์ ์ ๊ณตํ ์ ์์ต๋๋ค.
using System.Security.Cryptography;
...
var hashAlg = SHA1.Create();
โ ์๋ฃจ์
์๋ฃจ์ ์ ๋ค์๊ณผ ๊ฐ์ ๊ฐ๋ ฅํ ์ํธํ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํฉ๋๋ค.
SHA256 SHA1 ์๋
RIPEMD160์ด ์๋ SHA512
AES๊ฐ 3๋ฐฐ์ฒด๊ฐ ์๋๋ผ
๐ ์ ๋ฌผ์ ์ํ์ญ๋๊น?
๋ง์ฝ ๋ค๊ฐ ์ด ๊ธ์ ์ฝ๊ณ ์๋ค๋ฉด, ์ด๊ฒ์ ๋ค๊ฐ ๊ธ์ ์ฝ๋ ๋ง์ง๋ง 1%์ ์ํ๋ค๋ ๊ฒ์ ์๋ฏธํ๋ค. ๊ทธ๋์ ๋๋ ์ ๋ฌผ์ ๋ฐ์๋ค๐!!!! ์ฐ์ ๋ฑ์ ๋ฒ๋ ํ ๋ง๋ฆฌ๋ฅผ๐ฆ (์ด๋ ๊ฒ ํ๋ฉด ๋๋ ๋๊ฐ ์ ์ฒด ๋ฌธ์ฅ์ ์ฝ์ ์ถฉ์คํ ๋ ์์ธ์ง ์ ์ ์๋ค๐).
๋จ์ง ์ด ๋ฌธ์ฅ์ ๋ค์ด๊ฐ์ ์ด ๋ฌธ์ฅ์ ์ฌ๊ธฐ๊น์ง ์ค๊ฒ ํ๊ธฐ ์ํด์, ๋๋ ๋์๊ฒ ์ ๋ฌผ์ ํ๋ ์ฃผ๊ณ , ์ง์นจ์ ํ๋ ์ฃผ์ด ๋์ ๊ฑด๊ฐ์ ์ ์งํ๊ฒ ํ ๊ฒ์ด๋ค.NET ์ดํ๋ฆฌ์ผ์ด์ ๋ณด์๐.
๋ค๊ฐ ์ ์ผํ๊ฒ ํด์ผ ํ ์ผ์ ๋ค ์ด๋ฉ์ผ์ ์ ๋ ฅํด์ ๋ฌด๋ฃ๋ก ๋ฐ๋ ๊ฒ์ด๋ค๐ค.
๐จ ์ด๊ฒ์ ์์ํ ์กด์ฌํ์ง ์์ ๊ฒ์ด๋ค.
๋ฐฐํ์ฑ์ ์ ์งํ๊ธฐ ์ํด์, ๋๋ ๊ณง ์ด ๋ฌธ์ฅ์ ํธ์งํ ๊ฒ์ด๋ฉฐ, ๋ ์ด์ ์ ๋ฌผ์ด ์์ ๊ฒ์ด๋ค.๊ทธ๋ฌ๋ ์ด์ ๋น์ ์ ์๋ด์๋ฅผ ์ฐพ์๊ฐ์ ํ๋ฅญํ ๊ต์ฌ๊ฐ ๋๋๋ก ํ์ธ์.๋คํธ์ํฌ ๋ณด์ ์ ๋ฌธ๊ฐ!๐๐๐
Download FREE guide ๐
Reference
์ด ๋ฌธ์ ์ ๊ดํ์ฌ(๐จC# ํ๋ก๊ทธ๋๋จธ ์ค๋ฅ 7๊ฐ๐(์ ๋ฌผ)), ์ฐ๋ฆฌ๋ ์ด๊ณณ์์ ๋ ๋ง์ ์๋ฃ๋ฅผ ๋ฐ๊ฒฌํ๊ณ ๋งํฌ๋ฅผ ํด๋ฆญํ์ฌ ๋ณด์๋ค https://dev.to/dotnetsafer/7-mistakes-made-by-c-programmers-gift-5agcํ ์คํธ๋ฅผ ์์ ๋กญ๊ฒ ๊ณต์ ํ๊ฑฐ๋ ๋ณต์ฌํ ์ ์์ต๋๋ค.ํ์ง๋ง ์ด ๋ฌธ์์ URL์ ์ฐธ์กฐ URL๋ก ๋จ๊ฒจ ๋์ญ์์ค.
์ฐ์ํ ๊ฐ๋ฐ์ ์ฝํ ์ธ ๋ฐ๊ฒฌ์ ์ ๋ (Collection and Share based on the CC Protocol.)
์ข์ ์นํ์ด์ง ์ฆ๊ฒจ์ฐพ๊ธฐ
๊ฐ๋ฐ์ ์ฐ์ ์ฌ์ดํธ ์์ง
๊ฐ๋ฐ์๊ฐ ์์์ผ ํ ํ์ ์ฌ์ดํธ 100์ ์ถ์ฒ ์ฐ๋ฆฌ๋ ๋น์ ์ ์ํด 100๊ฐ์ ์์ฃผ ์ฌ์ฉํ๋ ๊ฐ๋ฐ์ ํ์ต ์ฌ์ดํธ๋ฅผ ์ ๋ฆฌํ์ต๋๋ค