सी # int32

Question

से प्राप्त होने वाला # मेरे पास 'आईडी' नामक सदस्यों के साथ कई कक्षाएं हैं। मूल रूप से मैं इन्हें इनट्स के रूप में स्टोर करना चाहता था, लेकिन मुझे यह सुनिश्चित करने के लिए सुरक्षा की कुछ परत चाहिए कि मैं किसी व्यक्ति को गलती से कमरे आईडी निर्दिष्ट नहीं करता हूं।

एक समाधान टाइपिफ़ (कक्ष Id = सिस्टम का उपयोग करके) होगा। Int32;) लेकिन फिर मुझे इन फ़ाइलों का उपयोग करके सभी फाइलों में कोड की उस पंक्ति की आवश्यकता है। मैं पसंद करूंगा उदा। int32 से व्युत्पन्न एक RoomId क्लास, लेकिन मैं यह नहीं समझ सकता कि स्पष्ट रूपांतरण (initilisation के लिए)

या मुझे इसे किसी अन्य तरीके से करना चाहिए?

Answer 1

यदि मैं सही ढंग से समझता हूं, तो आपको केवल एक ही ऑपरेशन की आवश्यकता है जो समानता के लिए तुलना है। आप एक RoomId वर्ग (या struct, जो भी आप सूट)

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; 

आप IEquatable लागू कर सकते हैं बना सकते हैं, समानता और असमानता ऑपरेटरों को ओवरलोड अगर आप चाहते हैं। यदि आपको दृढ़ता की आवश्यकता है, तो आप यह सुनिश्चित करने के लिए ISERializable इंटरफ़ेस को कार्यान्वित कर सकते हैं कि पूर्णांक मान केवल कक्षा से "बच निकले" यदि वास्तव में इसकी आवश्यकता हो।

Answer 2

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

फिर आप कर सकता है:

RoomId variable = (RoomId)10; 

यह Int32 या सी # में किसी भी अन्य मान प्रकार से एक वर्ग प्राप्त करने के लिए संभव नहीं है।

Answer 3

आप .NET में मूल्य प्रकार (Intcts सहित structs) का वारिस नहीं कर सकते हैं।

निकटतम विकल्प एक ऐसी संरचना बनाना होगा जिसमें आपके Int32 के अलावा कुछ भी न हो। इसके लिए एक ही स्थान की आवश्यकता होगी, लेकिन आपकी सटीक संरचना तक सीमित हो सकती है। यदि आवश्यक हो तो आप अन्य जानकारी को शामिल करने के लिए बाद में अपनी संरचना बदल सकते हैं। (हालांकि, यह जागरूक रहें कि यह शायद एक ब्रेकिंग एपीआई परिवर्तन होगा।)

Answer 4

आप Int32 से प्राप्त नहीं सकता, लेकिन आप अंतर्निहित रूपांतरण है, जो आप व्यवहार आप की जरूरत दे सकता है निर्दिष्ट कर सकते हैं:

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

मेरी प्राथमिकता पर कस्टम प्रकार उत्पन्न करने के लिए एक सरल टी -4 टेम्पलेट का उपयोग करने के लिए है उड़ना। यहां एक उदाहरण है जिसका मैंने हाल ही में एक निजी परियोजना पर उपयोग किया था। लाइन 10 पर, जेनरेट किए गए प्रकारों की एक सूची है। इनमें से प्रत्येक चीज int थी, लेकिन अब वे दृढ़ता से टाइप की गई हैं।

यह सामान्य "आदिम जुनून" विरोधी पैटर्न से बचकर एक और अधिक कार्यात्मक प्रतिमान का उपयोग करने के लिए आपके कोड को भी स्थानांतरित करता है।

मैं जिस टेम्पलेट का उपयोग कर रहा हूं वह है। अपडेट/संशोधित करने के लिए स्वतंत्र महसूस करें (यदि आप कुछ भी उपयोगी जोड़ते हैं तो हम सभी को बताएं)।

<#@ 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}"; 
    } 
<# 
    } 
#>