unmanaged, notnull, new() (emulacja w C# 6)
C# 6 obsługuje ograniczenia class/struct/new(); proszę emulować nowsze ograniczenia notnull/unmanaged za pomocą walidacji, kształtu API i konwencji.
unmanaged, notnull, new() (emulacja w C# 6) to bezpłatna lekcja C# Academy na CoddyKit. To lekcja 1 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C# Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C# Academy zawiera 3 lekcji w sumie.
Przegląd ograniczeń
Cel: Efektywnie używać ograniczeń generycznych C# 6.
- class a struct
- new() do tworzenia bez użycia Activator
- Emulowanie notnull/unmanaged za pomocą guardów i projektu API
class a struct
class ogranicza T do typów referencyjnych, a struct ogranicza T do typów wartościowych. Niepoprawne użycie kończy się błędem kompilacji.
using System;
// Works only for reference types
public static class RefBox
{
public static string Show<T>(T value) where T : class
{
return value == null ? "null ref" : "ref: " + value.ToString();
}
}
// Works only for value types
public static class ValBox
{
public static string Show<T>(T value) where T : struct
{
return "value: " + value.ToString();
}
}
public class Program
{
public static void Main(string[] args)
{
string s = "hello";
int n = 42;
Console.WriteLine(RefBox.Show<string>(s)); // OK
Console.WriteLine(ValBox.Show<int>(n)); // OK
// Console.WriteLine(RefBox.Show<int>(n)); // compile-time error (int is struct)
// Console.WriteLine(ValBox.Show<string>(s)); // compile-time error (string is class)
}
}
new() w praktyce
new() gwarantuje publiczny konstruktor bezparametrowy, dzięki czemu kod generyczny może bezpośrednio wywołać new T().
using System;
// Requires public parameterless ctor on T
public static class Factory
{
public static T Create<T>() where T : new()
{
return new T(); // safe in C# 6 with new()
}
}
public sealed class Sample
{
public string Name { get; set; }
public Sample() { Name = "default"; }
}
public class Program
{
public static void Main(string[] args)
{
Sample x = Factory.Create<Sample>();
Console.WriteLine("Created: " + x.Name);
}
}
Emulowanie notnull
W C# 6 nie ma notnull. Można je przybliżyć za pomocą where T : class oraz jawnych guardów null wewnątrz API.
using System;
// C# 6 has no notnull constraint. Use where T : class and guard at runtime.
public static class NotNullApi
{
public static int LengthOf<T>(T x) where T : class
{
if (x == null) throw new ArgumentNullException("x");
return x.ToString().Length; // placeholder usage
}
}
public class Program
{
public static void Main(string[] args)
{
Console.WriteLine(NotNullApi.LengthOf<string>("hi")); // 2
try
{
Console.WriteLine(NotNullApi.LengthOf<string>(null)); // throws
}
catch (Exception ex)
{
Console.WriteLine("Guard fired: " + ex.GetType().Name);
}
}
}
Emulowanie założeń unmanaged
W C# 6 nie ma unmanaged. Można użyć struct i interfejsów (np. IComparable), aby kierować rozwiązanie do typów wartościowych podobnych do liczbowych.
using System;
// No unmanaged constraint in C# 6.
// Use struct for value types and restrict API usage (document numeric-only intent).
public static class NumericOps
{
public static T Max<T>(T a, T b) where T : struct, IComparable
{
// Works for numeric primitives because they implement IComparable
return (a.CompareTo(b) >= 0) ? a : b;
}
}
public class Program
{
public static void Main(string[] args)
{
Console.WriteLine(NumericOps.Max<int>(3, 9)); // 9
Console.WriteLine(NumericOps.Max<double>(2.5, 2)); // 2.5
}
}
Praktyczne wskazówki
Wskazówki:
- Należy wybrać class/struct, aby wcześnie zawęzić T.
- Należy użyć new(), jeśli konieczne jest tworzenie T.
- Należy emulować notnull za pomocą guardów sprawdzających null.
- Należy emulować unmanaged za pomocą struct oraz udokumentowanego sposobu użycia (często dla prymitywnych typów liczbowych).
Ograniczenie konstruktora
Podsumowanie
Podsumowanie: W C# 6 należy używać class/struct/new(). notnull należy emulować za pomocą sprawdzania null, a założenia unmanaged — za pomocą ograniczeń struct + interfejs.
Często zadawane pytania
Czy lekcja „unmanaged, notnull, new() (emulacja w C# 6)” jest bezpłatna?
Tak — pełny tekst „unmanaged, notnull, new() (emulacja w C# 6)” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C# Academy, przejdź na CoddyKit PRO. Kurs C# Academy zawiera 3 lekcji w sumie.
Co nauczysz się w „unmanaged, notnull, new() (emulacja w C# 6)”?
C# 6 obsługuje ograniczenia class/struct/new(); proszę emulować nowsze ograniczenia notnull/unmanaged za pomocą walidacji, kształtu API i konwencji. Ćwiczysz C# Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć C# Academy?
Nie wymagamy żadnego doświadczenia. C# Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 3.
Ile czasu zajmuje lekcja „unmanaged, notnull, new() (emulacja w C# 6)”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji C# Academy?
Tak. Każda lekcja C# Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- unmanaged, notnull, new() (emulacja w C# 6)
- Matematyka generyczna (omówienie), atrybuty generyczne (gdy mają zastosowanie)
- Wielokrotnego użytku narzędzia generyczne