C# pochodzące z Int32

Question

Mam kilka klas z członkami o nazwie "Id". Pierwotnie chciałem przechowywać te pliki jako ints, ale chciałbym mieć jakąś warstwę ochronną, aby upewnić się, że nie przypisze się przypadkowo identyfikatora pokoju do osoby itp.

Jednym z rozwiązań będzie typedef (przy użyciu RoomId = System. Int32;), ale potrzebuję tej linii kodu we wszystkich plikach, które ją używają. wolałbym np. klasa RoomId wywodząca się z klasy int32, ale nie wiem, jak ją skonfigurować, aby umożliwić jawną konwersję (w celu inicjalizacji):

czy powinienem to zrobić w jakiś inny sposób?

Answer 1

Jeśli dobrze rozumiem, jedyną czynnością, której naprawdę potrzebujesz, jest porównanie pod kątem równości. Można utworzyć klasę RoomId (lub struct, cokolwiek pasuje do Ciebie)

class RoomId 
{ 
    private int Value {get; set;} 

    public RoomId(int value) 
    { 
     this.Value = value; 
    } 

    public bool Equals(RoomId other) 
    { 
     return this.Value == other.Value; 
    } 
} 

RoomId room1 = new RoomId(1); 
RoomId room2 = new RoomId(2); 

// To compare for equality 
bool isItTheSameRoom = room1.Equals(room2); 
// Or if you have overloaded the equality operator (==) 
bool isItTheSameRoom = room1 == room2; 

można wdrożyć IEquatable, przeciążanie operatorów równości i nierówności, jeśli chcesz. Jeśli potrzebujesz uporczywości, możesz zaimplementować interfejs ISerializable, aby upewnić się, że wartość całkowita "wymyka się" z klasy, jeśli jest naprawdę potrzebna.

Answer 2

public static explicit operator RoomId(int value) { 
    return new RoomId { Id = value }; 
} 

Można wtedy zrobić:

RoomId variable = (RoomId)10; 

To nie jest możliwe określenie klasy z Int32 lub innego rodzaju wartości w C#.

Answer 3

Nie można dziedziczyć typów wartości (struktur, w tym Int32) w .NET.

Najbliższą opcją byłoby utworzenie struktury, która nie zawierała nic oprócz twojego Int32. Wymagałoby to tego samego miejsca, ale może być ograniczone do twojej dokładnej struktury. Następnie możesz później zmienić strukturę, aby w razie potrzeby uwzględnić inne informacje. (Pamiętaj jednak, że prawdopodobnie będzie to zmiana API).

Answer 4

Nie można czerpać z Int32, ale można określić niejawne konwersje, które może dać zachowanie co potrzeba:

public struct RoomId 
{ 
    private int _Value; 

    public static implicit operator RoomId(int value) 
    { 
     return new RoomId { _Value = value }; 
    } 

    public static implicit operator int(RoomId value) 
    { 
     return value._Value; 
    } 
} 

// ... 

RoomId id = 42; 

Console.WriteLine(id == 41); // False 
Console.WriteLine(id == 42); // True 
Console.WriteLine(id < 42);  // False 
Console.WriteLine(id > 41);  // True 
Console.WriteLine(id * 2);  // 84 

Answer 5

Moje preferencja jest użycie prostego szablonu T4 generować niestandardowe typy na latać. Oto przykład, który ostatnio wykorzystałem w prywatnym projekcie. W linii 10 znajduje się lista generowanych typów. Każda z tych rzeczy kiedyś była int, ale teraz są mocno wpisane.

Przenosi to również twój kod w kierunku bardziej funkcjonalnego paradygmatu, unikając zwykłej antyparty "prymitywnej obsesji".

Istnieje szablon, którego używam. Zapraszam do aktualizacji/modyfikacji (niech reszta z nas wie, czy dodasz coś użytecznego).

<#@ template debug="false" hostspecific="false" language="C#" #> 
<#@ assembly name="System.Core" #> 
<#@ import namespace="System.Linq" #> 
<#@ import namespace="System.Text" #> 
<#@ import namespace="System.Collections.Generic" #> 
<#@ output extension=".cs" #> 
<# 

// List of types to generate: 
var createTypeList = new[] { "XDim", "YDim", "YDelta", "DelayValue", "HValue", "Score", "TplIndexValue" }; 

#> 
using System; 
using System.Collections.Generic; 
using System.ComponentModel; 
using System.Diagnostics.Contracts; 
// ReSharper disable CheckNamespace 

<# 
    for(int i = 0; i < createTypeList.Length; i++) 
    { 
     var typeName = createTypeList[i]; 
#> 

    [ImmutableObject(true)] 
    public struct <#=typeName#> : IComparable<<#=typeName#>> 
    { 
     public <#=typeName#>(int value) { Value = value; } 

     [Pure] public int Value { get; } 
     [Pure] public bool Equals(<#=typeName#> other) => Value == other.Value; 

     [Pure] 
     public override bool Equals(object obj) 
     { 
      if (ReferenceEquals(null, obj)) return false; 
      if (Equals(this, obj)) return true; 
      return obj.GetType() == GetType() && Equals((<#=typeName#>)obj); 
     } 

     [Pure] 
     public override int GetHashCode() 
     { 
      unchecked 
      { 
       return (base.GetHashCode() * 397)^Value; 
      } 
     } 

     [Pure] public static bool operator ==(<#=typeName#> left, <#=typeName#> right) => Equals(left, right); 
     [Pure] public static bool operator !=(<#=typeName#> left, <#=typeName#> right) => !Equals(left, right); 
     [Pure] public int CompareTo(<#=typeName#> other) => Equals(this, other) ? 0 : Value.CompareTo(other.Value); 
     [Pure] public static bool operator <(<#=typeName#> left, <#=typeName#> right) => Comparer<<#=typeName#>>.Default.Compare(left, right) < 0; 
     [Pure] public static bool operator >(<#=typeName#> left, <#=typeName#> right) => Comparer<<#=typeName#>>.Default.Compare(left, right) > 0; 
     [Pure] public static bool operator <=(<#=typeName#> left, <#=typeName#> right) => Comparer<<#=typeName#>>.Default.Compare(left, right) <= 0; 
     [Pure] public static bool operator >=(<#=typeName#> left, <#=typeName#> right) => Comparer<<#=typeName#>>.Default.Compare(left, right) >= 0; 
     [Pure] public override string ToString() => $"{nameof(Value)}: {Value}"; 
    } 
<# 
    } 
#>