ValueType Klasse
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Stellt die Basisklasse für Werttypen bereit.
public ref class ValueType abstractpublic abstract class ValueType[System.Serializable]
public abstract class ValueType[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class ValueTypetype ValueType = class[<System.Serializable>]
type ValueType = class[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type ValueType = classPublic MustInherit Class ValueType- Vererbung
-
ValueType
- Abgeleitet
- Attribute
Hinweise
ValueType überschreibt die virtuellen Methoden von Object mit geeigneteren Implementierungen für Werttypen. Siehe auch Enum, das von ValueTypeerbt.
Datentypen werden in Werttypen und Verweistypen unterteilt. Werttypen sind entweder stapelseitig zugeordnet oder inline in einer -Struktur zugeordnet. Verweistypen sind heapseitig zugeordnet. Sowohl Verweis- als auch Werttypen werden von der ultimativen Basisklasse Objectabgeleitet. In Fällen, in denen sich ein Werttyp wie ein Objekt verhält, wird ein Wrapper, der den Werttyp wie ein Verweisobjekt aussehen lässt, auf dem Heap zugeordnet, und der Wert des Werttyps wird in ihn kopiert. Der Wrapper ist markiert, sodass das System weiß, dass er einen Werttyp enthält. Dieser Prozess wird als Boxen bezeichnet, und der umgekehrte Prozess wird als Unboxing bezeichnet. Durch Boxen und Unboxing kann jeder Typ als Objekt behandelt werden.
Obwohl ValueType die implizite Basisklasse für Werttypen ist, können Sie keine Klasse erstellen, die direkt von ValueType erbt. Stattdessen stellen einzelne Compiler eine Sprache Schlüsselwort (keyword) oder ein Konstrukt (zstruct. B. in C# und Structure...End Structure in Visual Basic) bereit, um die Erstellung von Werttypen zu unterstützen.
Abgesehen davon, dass sie als Basisklasse für Werttypen im .NET Framework dient, wird die ValueType -Struktur im Allgemeinen nicht direkt im Code verwendet. Es kann jedoch als Parameter in Methodenaufrufen verwendet werden, um mögliche Argumente auf Werttypen anstelle aller Objekte einzuschränken, oder um einer Methode die Verarbeitung einer Reihe verschiedener Werttypen zu ermöglichen. Das folgende Beispiel veranschaulicht, wie verhindert wird, dass ValueType Verweistypen an Methoden übergeben werden. Sie definiert eine Klasse namens Utility , die vier Methoden enthält: IsNumeric, die angibt, ob ihr Argument eine Zahl ist; IsInteger, die angibt, ob das Argument eine ganze Zahl ist; IsFloat, die angibt, ob das Argument eine Gleitkommazahl ist; und Compare, die die Beziehung zwischen zwei numerischen Werten angibt. In jedem Fall sind die Methodenparameter vom Typ ValueType, und Verweistypen werden daran gehindert, an die Methoden übergeben zu werden.
using System;
using System.Numerics;
public class Utility
{
public enum NumericRelationship {
GreaterThan = 1,
EqualTo = 0,
LessThan = -1
};
public static NumericRelationship Compare(ValueType value1, ValueType value2)
{
if (! IsNumeric(value1))
throw new ArgumentException("value1 is not a number.");
else if (! IsNumeric(value2))
throw new ArgumentException("value2 is not a number.");
// Use BigInteger as common integral type
if (IsInteger(value1) && IsInteger(value2)) {
BigInteger bigint1 = (BigInteger) value1;
BigInteger bigint2 = (BigInteger) value2;
return (NumericRelationship) BigInteger.Compare(bigint1, bigint2);
}
// At least one value is floating point; use Double.
else {
Double dbl1 = 0;
Double dbl2 = 0;
try {
dbl1 = Convert.ToDouble(value1);
}
catch (OverflowException) {
Console.WriteLine("value1 is outside the range of a Double.");
}
try {
dbl2 = Convert.ToDouble(value2);
}
catch (OverflowException) {
Console.WriteLine("value2 is outside the range of a Double.");
}
return (NumericRelationship) dbl1.CompareTo(dbl2);
}
}
public static bool IsInteger(ValueType value)
{
return (value is SByte || value is Int16 || value is Int32
|| value is Int64 || value is Byte || value is UInt16
|| value is UInt32 || value is UInt64
|| value is BigInteger);
}
public static bool IsFloat(ValueType value)
{
return (value is float | value is double | value is Decimal);
}
public static bool IsNumeric(ValueType value)
{
return (value is Byte ||
value is Int16 ||
value is Int32 ||
value is Int64 ||
value is SByte ||
value is UInt16 ||
value is UInt32 ||
value is UInt64 ||
value is BigInteger ||
value is Decimal ||
value is Double ||
value is Single);
}
}
open System
open System.Numerics
module Utility =
type NumericRelationship =
| GreaterThan = 1
| EqualTo = 0
| LessThan = -1
let isInteger (value: ValueType) =
match value with
| :? sbyte | :? int16 | :? int32 | :? int64
| :? byte | :? uint16 | :? uint32
| :? uint64 | :? bigint -> true
| _ -> false
let isFloat (value: ValueType) =
match value with
| :? float32 | :? float | :? decimal -> true
| _ -> false
let tryToBigInt (value: ValueType) =
match value with
| :? sbyte as v -> bigint v |> Some
| :? int16 as v -> bigint v |> Some
| :? int32 as v -> bigint v |> Some
| :? int64 as v -> bigint v |> Some
| :? byte as v -> bigint v |> Some
| :? uint16 as v -> bigint v |> Some
| :? uint32 as v -> bigint v |> Some
| :? uint64 as v -> bigint v |> Some
| :? float32 as v -> bigint v |> Some
| _ -> None
let isNumeric (value: ValueType) =
isInteger value || isFloat value
let compare (value1: ValueType) (value2: ValueType) =
if isNumeric value1 |> not then
invalidArg "value1" "value1 is not a number."
elif isNumeric value2 |> not then
invalidArg "value2" "value2 is not a number."
// Use BigInteger as common integral type
match tryToBigInt value1, tryToBigInt value2 with
| Some bigint1, Some bigint2 ->
BigInteger.Compare(bigint1, bigint2) |> enum<NumericRelationship>
// At least one value is floating point use Double.
| _ ->
let dbl1 =
try
Convert.ToDouble value1
with
| :? OverflowException ->
printfn "value1 is outside the range of a Double."
0.
| _ -> 0.
let dbl2 =
try
Convert.ToDouble value2
with
| :? OverflowException ->
printfn "value2 is outside the range of a Double."
0.
| _ -> 0.
dbl1.CompareTo dbl2 |> enum<NumericRelationship>
Imports System.Numerics
Public Class Utility
Public Enum NumericRelationship As Integer
GreaterThan = 1
EqualTo = 0
LessThan = -1
End Enum
Public Shared Function Compare(value1 As ValueType, value2 As ValueType) _
As NumericRelationship
If Not IsNumeric(value1) Then
Throw New ArgumentException("value1 is not a number.")
Else If Not IsNumeric(value2) Then
Throw New ArgumentException("value2 is not a number.")
Else
' Use BigInteger as common integral type
If isInteger(value1) And IsInteger(value2) Then
Dim bigint1 As BigInteger = CType(value1, BigInteger)
Dim bigInt2 As BigInteger = CType(value2, BigInteger)
Return CType(BigInteger.Compare(bigint1, bigint2), NumericRelationship)
' At least one value is floating point; use Double.
Else
Dim dbl1, dbl2 As Double
Try
dbl1 = CDbl(value1)
Catch e As OverflowException
Console.WriteLine("value1 is outside the range of a Double.")
End Try
Try
dbl2 = CDbl(value2)
Catch e As OverflowException
Console.WriteLine("value2 is outside the range of a Double.")
End Try
Return CType(dbl1.CompareTo(dbl2), NumericRelationship)
End If
End If
End Function
Public Shared Function IsInteger(value As ValueType) As Boolean
Return (TypeOf value Is SByte Or TypeOf value Is Int16 Or TypeOf value Is Int32 _
Or TypeOf value Is Int64 Or TypeOf value Is Byte Or TypeOf value Is UInt16 _
Or TypeOf value Is UInt32 Or TypeOf value Is UInt64 _
Or TypeOf value Is BigInteger)
End Function
Public Shared Function IsFloat(value As ValueType) As Boolean
Return (TypeOf value Is Single Or TypeOf value Is Double Or TypeOf value Is Decimal)
End Function
Public Shared Function IsNumeric(value As ValueType) As Boolean
Return TypeOf value Is Byte OrElse
TypeOf value Is Int16 OrElse
TypeOf value Is Int32 OrElse
TypeOf value Is Int64 OrElse
TypeOf value Is SByte OrElse
TypeOf value Is UInt16 OrElse
TypeOf value Is UInt32 OrElse
TypeOf value Is UInt64 OrElse
TypeOf value Is BigInteger OrElse
TypeOf value Is Decimal OrElse
TypeOf value Is Double OrElse
TypeOf value Is Single
End Function
End Class
Im folgenden Beispiel werden Aufrufe der Methoden der Utility -Klasse veranschaulicht.
public class Example
{
public static void Main()
{
Console.WriteLine(Utility.IsNumeric(12));
Console.WriteLine(Utility.IsNumeric(true));
Console.WriteLine(Utility.IsNumeric('c'));
Console.WriteLine(Utility.IsNumeric(new DateTime(2012, 1, 1)));
Console.WriteLine(Utility.IsInteger(12.2));
Console.WriteLine(Utility.IsInteger(123456789));
Console.WriteLine(Utility.IsFloat(true));
Console.WriteLine(Utility.IsFloat(12.2));
Console.WriteLine(Utility.IsFloat(12));
Console.WriteLine("{0} {1} {2}", 12.1, Utility.Compare(12.1, 12), 12);
}
}
// The example displays the following output:
// True
// False
// False
// False
// False
// True
// False
// True
// False
// 12.1 GreaterThan 12
printfn $"{Utility.isNumeric 12}"
printfn $"{Utility.isNumeric true}"
printfn $"{Utility.isNumeric 'c'}"
printfn $"{Utility.isNumeric (DateTime(2012, 1, 1))}"
printfn $"{Utility.isInteger 12.2}"
printfn $"{Utility.isInteger 123456789}"
printfn $"{Utility.isFloat true}"
printfn $"{Utility.isFloat 12.2}"
printfn $"{Utility.isFloat 12}"
printfn $"{12.1} {Utility.compare 12.1 12} {12}"
// The example displays the following output:
// True
// False
// False
// False
// False
// True
// False
// True
// False
// 12.1 GreaterThan 12
Module Example
Public Sub Main()
Console.WriteLine(Utility.IsNumeric(12))
Console.WriteLine(Utility.IsNumeric(True))
Console.WriteLine(Utility.IsNumeric("c"c))
Console.WriteLine(Utility.IsNumeric(#01/01/2012#))
Console.WriteLine(Utility.IsInteger(12.2))
Console.WriteLine(Utility.IsInteger(123456789))
Console.WriteLine(Utility.IsFloat(True))
Console.WriteLine(Utility.IsFloat(12.2))
Console.WriteLine(Utility.IsFloat(12))
Console.WriteLine("{0} {1} {2}", 12.1, Utility.Compare(12.1, 12), 12)
End Sub
End Module
' The example displays the following output:
' True
' False
' False
' False
' False
' True
' False
' True
' False
' 12.1 GreaterThan 12
Konstruktoren
| ValueType() |
Initialisiert eine neue Instanz der ValueType-Klasse. |
Methoden
| Equals(Object) |
Gibt an, ob diese Instanz und ein angegebenes Objekt gleich sind. |
| GetHashCode() |
Gibt den Hashcode für diese Instanz zurück. |
| GetType() |
Ruft den Type der aktuellen Instanz ab. (Geerbt von Object) |
| MemberwiseClone() |
Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object) |
| ToString() |
Gibt den voll qualifizierten Typnamen dieser Instanz zurück. |
Gilt für:
Weitere Informationen
Feedback
Feedback senden und anzeigen für