System.Boole yapısı
Bu makale, bu API'nin başvuru belgelerine ek açıklamalar sağlar.
Örneğin Boolean iki değeri olabilir: true veya false.
yapısı Boolean aşağıdaki görevleri destekleyen yöntemler sağlar:
- Boole değerlerini dizelere dönüştürme: ToString
- Dizeleri Boole değerlerine dönüştürmek için ayrıştırma: Parse ve TryParse
- Değerleri karşılaştırma: CompareTo ve Equals
Bu makalede bu görevler ve diğer kullanım ayrıntıları açıklanmaktadır.
Boole değerlerini biçimlendirme
dize gösterimi bir Boolean değer için "True" veya bir true değer için false "False" şeklindedir. Bir Boolean değerin dize gösterimi salt TrueString okunur ve FalseString alanlar tarafından tanımlanır.
Boole değerlerini dizelere dönüştürmek için yöntemini kullanırsınız ToString . Boole yapısı iki ToString aşırı yükleme içerir: parametresiz ToString() yöntem ve biçimlendirmeyi ToString(IFormatProvider) denetleyen bir parametre içeren yöntemi. Ancak, bu parametre yoksayıldığı için iki aşırı yükleme aynı dizeleri üretir. ToString(IFormatProvider) yöntemi kültüre duyarlı biçimlendirmeyi desteklemez.
Aşağıdaki örnekte yöntemiyle biçimlendirme gösterilmektedir ToString . C# ve VB örneklerinin bileşik biçimlendirme özelliğini, F# örneğinde ise dize ilişkilendirmesinin kullanıldığına dikkat edin. Her iki durumda ToString da yöntem örtük olarak çağrılır.
using System;
public class Example10
{
public static void Main()
{
bool raining = false;
bool busLate = true;
Console.WriteLine("It is raining: {0}", raining);
Console.WriteLine("The bus is late: {0}", busLate);
}
}
// The example displays the following output:
// It is raining: False
// The bus is late: True
let raining = false
let busLate = true
printfn $"It is raining: {raining}"
printfn $"The bus is late: {busLate}"
// The example displays the following output:
// It is raining: False
// The bus is late: True
Module Example9
Public Sub Main()
Dim raining As Boolean = False
Dim busLate As Boolean = True
Console.WriteLine("It is raining: {0}", raining)
Console.WriteLine("The bus is late: {0}", busLate)
End Sub
End Module
' The example displays the following output:
' It is raining: False
' The bus is late: True
Boolean Yapı yalnızca iki değere sahip olabileceğinden, özel biçimlendirme eklemek kolaydır. Diğer dize değişmez değerlerinin "True" ve "False" yerine kullanıldığı basit özel biçimlendirme için, C# dilindeki koşullu işleç veya Visual Basic'teki If işleci gibi diliniz tarafından desteklenen herhangi bir koşullu değerlendirme özelliğini kullanabilirsiniz. Aşağıdaki örnek, değerleri "True" ve "False" yerine "Evet" ve "Hayır" olarak biçimlendirmek Boolean için bu tekniği kullanır.
using System;
public class Example11
{
public static void Main()
{
bool raining = false;
bool busLate = true;
Console.WriteLine("It is raining: {0}",
raining ? "Yes" : "No");
Console.WriteLine("The bus is late: {0}",
busLate ? "Yes" : "No");
}
}
// The example displays the following output:
// It is raining: No
// The bus is late: Yes
Module Example
Public Sub Main()
Dim raining As Boolean = False
Dim busLate As Boolean = True
Console.WriteLine("It is raining: {0}",
If(raining, "Yes", "No"))
Console.WriteLine("The bus is late: {0}",
If(busLate, "Yes", "No"))
End Sub
End Module
' The example displays the following output:
' It is raining: No
' The bus is late: Yes
let raining = false
let busLate = true
printfn $"""It is raining: %s{if raining then "Yes" else "No"}"""
printfn $"""The bus is late: %s{if busLate then "Yes" else "No"}"""
// The example displays the following output:
// It is raining: No
// The bus is late: Yes
Kültüre duyarlı biçimlendirme de dahil olmak üzere daha karmaşık özel biçimlendirme işlemleri için yöntemini çağırabilir String.Format(IFormatProvider, String, Object[]) ve bir ICustomFormatter uygulama sağlayabilirsiniz. Aşağıdaki örnek, İngilizce (Birleşik Devletler), Fransızca (Fransa) ve Rusça (Rusya) kültürleri için kültüre duyarlı Boole dizeleri sağlamak için ve arabirimlerini uygular ICustomFormatterIFormatProvider.
using System;
using System.Globalization;
public class Example4
{
public static void Main()
{
String[] cultureNames = { "", "en-US", "fr-FR", "ru-RU" };
foreach (var cultureName in cultureNames) {
bool value = true;
CultureInfo culture = CultureInfo.CreateSpecificCulture(cultureName);
BooleanFormatter formatter = new BooleanFormatter(culture);
string result = string.Format(formatter, "Value for '{0}': {1}", culture.Name, value);
Console.WriteLine(result);
}
}
}
public class BooleanFormatter : ICustomFormatter, IFormatProvider
{
private CultureInfo culture;
public BooleanFormatter() : this(CultureInfo.CurrentCulture)
{ }
public BooleanFormatter(CultureInfo culture)
{
this.culture = culture;
}
public Object GetFormat(Type formatType)
{
if (formatType == typeof(ICustomFormatter))
return this;
else
return null;
}
public string Format(string fmt, Object arg, IFormatProvider formatProvider)
{
// Exit if another format provider is used.
if (! formatProvider.Equals(this)) return null;
// Exit if the type to be formatted is not a Boolean
if (! (arg is Boolean)) return null;
bool value = (bool) arg;
switch (culture.Name) {
case "en-US":
return value.ToString();
case "fr-FR":
if (value)
return "vrai";
else
return "faux";
case "ru-RU":
if (value)
return "верно";
else
return "неверно";
default:
return value.ToString();
}
}
}
// The example displays the following output:
// Value for '': True
// Value for 'en-US': True
// Value for 'fr-FR': vrai
// Value for 'ru-RU': верно
open System
open System.Globalization
type BooleanFormatter(culture) =
interface ICustomFormatter with
member this.Format(_, arg, formatProvider) =
if formatProvider <> this then null
else
match arg with
| :? bool as value ->
match culture.Name with
| "en-US" -> string arg
| "fr-FR" when value -> "vrai"
| "fr-FR" -> "faux"
| "ru-RU" when value -> "верно"
| "ru-RU" -> "неверно"
| _ -> string arg
| _ -> null
interface IFormatProvider with
member this.GetFormat(formatType) =
if formatType = typeof<ICustomFormatter> then this
else null
new() = BooleanFormatter CultureInfo.CurrentCulture
let cultureNames = [ ""; "en-US"; "fr-FR"; "ru-RU" ]
for cultureName in cultureNames do
let value = true
let culture = CultureInfo.CreateSpecificCulture cultureName
let formatter = BooleanFormatter culture
String.Format(formatter, "Value for '{0}': {1}", culture.Name, value)
|> printfn "%s"
// The example displays the following output:
// Value for '': True
// Value for 'en-US': True
// Value for 'fr-FR': vrai
// Value for 'ru-RU': верно
Imports System.Globalization
Module Example4
Public Sub Main()
Dim cultureNames() As String = {"", "en-US", "fr-FR", "ru-RU"}
For Each cultureName In cultureNames
Dim value As Boolean = True
Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture(cultureName)
Dim formatter As New BooleanFormatter(culture)
Dim result As String = String.Format(formatter, "Value for '{0}': {1}", culture.Name, value)
Console.WriteLine(result)
Next
End Sub
End Module
Public Class BooleanFormatter
Implements ICustomFormatter, IFormatProvider
Private culture As CultureInfo
Public Sub New()
Me.New(CultureInfo.CurrentCulture)
End Sub
Public Sub New(culture As CultureInfo)
Me.culture = culture
End Sub
Public Function GetFormat(formatType As Type) As Object _
Implements IFormatProvider.GetFormat
If formatType Is GetType(ICustomFormatter) Then
Return Me
Else
Return Nothing
End If
End Function
Public Function Format(fmt As String, arg As Object,
formatProvider As IFormatProvider) As String _
Implements ICustomFormatter.Format
' Exit if another format provider is used.
If Not formatProvider.Equals(Me) Then Return Nothing
' Exit if the type to be formatted is not a Boolean
If Not TypeOf arg Is Boolean Then Return Nothing
Dim value As Boolean = CBool(arg)
Select culture.Name
Case "en-US"
Return value.ToString()
Case "fr-FR"
If value Then
Return "vrai"
Else
Return "faux"
End If
Case "ru-RU"
If value Then
Return "верно"
Else
Return "неверно"
End If
Case Else
Return value.ToString()
End Select
End Function
End Class
' The example displays the following output:
' Value for '': True
' Value for 'en-US': True
' Value for 'fr-FR': vrai
' Value for 'ru-RU': верно
İsteğe bağlı olarak, kültüre özgü Boole dizelerini tanımlamak için kaynak dosyalarını kullanabilirsiniz.
Boole değerlerine ve değerlerinden dönüştürme
yapısı Boolean arabirimini IConvertible uygular. Sonuç olarak sınıfını Convert kullanarak bir Boolean değer ile .NET'teki diğer ilkel türler arasında dönüştürmeler gerçekleştirebilir veya yapının açık uygulamalarını çağırabilirsiniz Boolean . Ancak, ve Boolean aşağıdaki türler arasındaki dönüştürmeler desteklenmez, bu nedenle ilgili dönüştürme yöntemleri bir InvalidCastException özel durum oluşturur:
ve Char (Convert.ToBoolean(Char)ve Convert.ToChar(Boolean) yöntemleri) arasında Boolean dönüştürme.
ve DateTime (Convert.ToBoolean(DateTime)ve Convert.ToDateTime(Boolean) yöntemleri) arasında Boolean dönüştürme.
Tamsayı veya kayan nokta sayılarından Boole değerlerine yapılan tüm dönüştürmeler sıfır olmayan değerleri true ve sıfır değerlerini falsedeğerine dönüştürür. Aşağıdaki örnek, sınıfın seçili aşırı yüklemelerini Convert.ToBoolean çağırarak bunu gösterir.
using System;
public class Example2
{
public static void Main()
{
Byte byteValue = 12;
Console.WriteLine(Convert.ToBoolean(byteValue));
Byte byteValue2 = 0;
Console.WriteLine(Convert.ToBoolean(byteValue2));
int intValue = -16345;
Console.WriteLine(Convert.ToBoolean(intValue));
long longValue = 945;
Console.WriteLine(Convert.ToBoolean(longValue));
SByte sbyteValue = -12;
Console.WriteLine(Convert.ToBoolean(sbyteValue));
double dblValue = 0;
Console.WriteLine(Convert.ToBoolean(dblValue));
float sngValue = .0001f;
Console.WriteLine(Convert.ToBoolean(sngValue));
}
}
// The example displays the following output:
// True
// False
// True
// True
// True
// False
// True
open System
let byteValue = 12uy
printfn $"{Convert.ToBoolean byteValue}"
let byteValue2 = 0uy
printfn $"{Convert.ToBoolean byteValue2}"
let intValue = -16345
printfn $"{Convert.ToBoolean intValue}"
let longValue = 945L
printfn $"{Convert.ToBoolean longValue}"
let sbyteValue = -12y
printfn $"{Convert.ToBoolean sbyteValue}"
let dblValue = 0.0
printfn $"{Convert.ToBoolean dblValue}"
let sngValue = 0.0001f
printfn $"{Convert.ToBoolean sngValue}"
// The example displays the following output:
// True
// False
// True
// True
// True
// False
// True
Module Example2
Public Sub Main()
Dim byteValue As Byte = 12
Console.WriteLine(Convert.ToBoolean(byteValue))
Dim byteValue2 As Byte = 0
Console.WriteLine(Convert.ToBoolean(byteValue2))
Dim intValue As Integer = -16345
Console.WriteLine(Convert.ToBoolean(intValue))
Dim longValue As Long = 945
Console.WriteLine(Convert.ToBoolean(longValue))
Dim sbyteValue As SByte = -12
Console.WriteLine(Convert.ToBoolean(sbyteValue))
Dim dblValue As Double = 0
Console.WriteLine(Convert.ToBoolean(dblValue))
Dim sngValue As Single = 0.0001
Console.WriteLine(Convert.ToBoolean(sngValue))
End Sub
End Module
' The example displays the following output:
' True
' False
' True
' True
' True
' False
' True
Boole değerini sayısal değerlere dönüştürürken, sınıfın dönüştürme yöntemleri Convert 1 ve false 0'a dönüştürülürtrue. Ancak, Visual Basic dönüştürme işlevleri 255'e (değerlere dönüştürmeler için) veya -1'e Byte (diğer tüm sayısal dönüştürmeler için) dönüştürülürtrue. Aşağıdaki örnek, bir Convert yöntem kullanarak ve Visual Basic örneğinde Visual Basic dilinin kendi dönüştürme işlecini kullanarak sayısal değerlere dönüştürürtrue.
using System;
public class Example3
{
public static void Main()
{
bool flag = true;
byte byteValue;
byteValue = Convert.ToByte(flag);
Console.WriteLine("{0} -> {1}", flag, byteValue);
sbyte sbyteValue;
sbyteValue = Convert.ToSByte(flag);
Console.WriteLine("{0} -> {1}", flag, sbyteValue);
double dblValue;
dblValue = Convert.ToDouble(flag);
Console.WriteLine("{0} -> {1}", flag, dblValue);
int intValue;
intValue = Convert.ToInt32(flag);
Console.WriteLine("{0} -> {1}", flag, intValue);
}
}
// The example displays the following output:
// True -> 1
// True -> 1
// True -> 1
// True -> 1
open System
let flag = true
let byteValue = Convert.ToByte flag
printfn $"{flag} -> {byteValue}"
let sbyteValue = Convert.ToSByte flag
printfn $"{flag} -> {sbyteValue}"
let dblValue = Convert.ToDouble flag
printfn $"{flag} -> {dblValue}"
let intValue = Convert.ToInt32(flag);
printfn $"{flag} -> {intValue}"
// The example displays the following output:
// True -> 1
// True -> 1
// True -> 1
// True -> 1
Module Example3
Public Sub Main()
Dim flag As Boolean = True
Dim byteValue As Byte
byteValue = Convert.ToByte(flag)
Console.WriteLine("{0} -> {1} ({2})", flag, byteValue,
byteValue.GetType().Name)
byteValue = CByte(flag)
Console.WriteLine("{0} -> {1} ({2})", flag, byteValue,
byteValue.GetType().Name)
Dim sbyteValue As SByte
sbyteValue = Convert.ToSByte(flag)
Console.WriteLine("{0} -> {1} ({2})", flag, sbyteValue,
sbyteValue.GetType().Name)
sbyteValue = CSByte(flag)
Console.WriteLine("{0} -> {1} ({2})", flag, sbyteValue,
sbyteValue.GetType().Name)
Dim dblValue As Double
dblValue = Convert.ToDouble(flag)
Console.WriteLine("{0} -> {1} ({2})", flag, dblValue,
dblValue.GetType().Name)
dblValue = CDbl(flag)
Console.WriteLine("{0} -> {1} ({2})", flag, dblValue,
dblValue.GetType().Name)
Dim intValue As Integer
intValue = Convert.ToInt32(flag)
Console.WriteLine("{0} -> {1} ({2})", flag, intValue,
intValue.GetType().Name)
intValue = CInt(flag)
Console.WriteLine("{0} -> {1} ({2})", flag, intValue,
intValue.GetType().Name)
End Sub
End Module
' The example displays the following output:
' True -> 1 (Byte)
' True -> 255 (Byte)
' True -> 1 (SByte)
' True -> -1 (SByte)
' True -> 1 (Double)
' True -> -1 (Double)
' True -> 1 (Int32)
' True -> -1 (Int32)
'den Boolean dize değerlerine dönüştürmeler için Boole değerlerini biçimlendirme bölümüne bakın. Dizelerden değerlere dönüştürmeler için Boolean Boole değerlerini ayrıştırma bölümüne bakın.
Boole değerlerini ayrıştırma
Yapı Boolean , Parse bir dizeyi Boole değerine dönüştüren iki statik ayrıştırma yöntemi ve TryParseiçerir. Boole değerinin dize gösterimi, sırasıyla "True" ve "False" olan ve FalseString alanlarının değerlerinin TrueString büyük/küçük harfe duyarlı olmayan eşdeğerleri tarafından tanımlanır. Başka bir deyişle, başarılı bir şekilde ayrıştıran dizeler yalnızca "True", "False", "true", "false" veya bazı karma büyük/küçük harf eşdeğerleridir. "0" veya "1" gibi sayısal dizeleri başarıyla ayrıştıramazsınız. Dize karşılaştırması yapılırken baştaki veya sondaki boşluk karakterleri dikkate alınmaz.
Aşağıdaki örnek, bir dizi dizeyi Parse ayrıştırmak için ve TryParse yöntemlerini kullanır. Yalnızca "True" ve "False" büyük/küçük harfe duyarlı olmayan eşdeğerlerinin başarıyla ayrıştırılabildiğini unutmayın.
using System;
public class Example7
{
public static void Main()
{
string[] values = { null, String.Empty, "True", "False",
"true", "false", " true ",
"TrUe", "fAlSe", "fa lse", "0",
"1", "-1", "string" };
// Parse strings using the Boolean.Parse method.
foreach (var value in values) {
try {
bool flag = Boolean.Parse(value);
Console.WriteLine("'{0}' --> {1}", value, flag);
}
catch (ArgumentException) {
Console.WriteLine("Cannot parse a null string.");
}
catch (FormatException) {
Console.WriteLine("Cannot parse '{0}'.", value);
}
}
Console.WriteLine();
// Parse strings using the Boolean.TryParse method.
foreach (var value in values) {
bool flag = false;
if (Boolean.TryParse(value, out flag))
Console.WriteLine("'{0}' --> {1}", value, flag);
else
Console.WriteLine("Unable to parse '{0}'", value);
}
}
}
// The example displays the following output:
// Cannot parse a null string.
// Cannot parse ''.
// 'True' --> True
// 'False' --> False
// 'true' --> True
// 'false' --> False
// ' true ' --> True
// 'TrUe' --> True
// 'fAlSe' --> False
// Cannot parse 'fa lse'.
// Cannot parse '0'.
// Cannot parse '1'.
// Cannot parse '-1'.
// Cannot parse 'string'.
//
// Unable to parse ''
// Unable to parse ''
// 'True' --> True
// 'False' --> False
// 'true' --> True
// 'false' --> False
// ' true ' --> True
// 'TrUe' --> True
// 'fAlSe' --> False
// Cannot parse 'fa lse'.
// Unable to parse '0'
// Unable to parse '1'
// Unable to parse '-1'
// Unable to parse 'string'
open System
let values =
[ null; String.Empty; "True"; "False"
"true"; "false"; " true "
"TrUe"; "fAlSe"; "fa lse"; "0"
"1"; "-1"; "string" ]
// Parse strings using the Boolean.Parse method.
for value in values do
try
let flag = Boolean.Parse value
printfn $"'{value}' --> {flag}"
with
| :? ArgumentException ->
printfn "Cannot parse a null string."
| :? FormatException ->
printfn $"Cannot parse '{value}'."
printfn ""
// Parse strings using the Boolean.TryParse method.
for value in values do
match Boolean.TryParse value with
| true, flag ->
printfn $"'{value}' --> {flag}"
| false, _ ->
printfn $"Unable to parse '{value}'"
// The example displays the following output:
// Cannot parse a null string.
// Cannot parse ''.
// 'True' --> True
// 'False' --> False
// 'true' --> True
// 'false' --> False
// ' true ' --> True
// 'TrUe' --> True
// 'fAlSe' --> False
// Cannot parse 'fa lse'.
// Cannot parse '0'.
// Cannot parse '1'.
// Cannot parse '-1'.
// Cannot parse 'string'.
//
// Unable to parse ''
// Unable to parse ''
// 'True' --> True
// 'False' --> False
// 'true' --> True
// 'false' --> False
// ' true ' --> True
// 'TrUe' --> True
// 'fAlSe' --> False
// Cannot parse 'fa lse'.
// Unable to parse '0'
// Unable to parse '1'
// Unable to parse '-1'
// Unable to parse 'string'
Module Example7
Public Sub Main()
Dim values() As String = {Nothing, String.Empty, "True", "False",
"true", "false", " true ",
"TrUe", "fAlSe", "fa lse", "0",
"1", "-1", "string"}
' Parse strings using the Boolean.Parse method.
For Each value In values
Try
Dim flag As Boolean = Boolean.Parse(value)
Console.WriteLine("'{0}' --> {1}", value, flag)
Catch e As ArgumentException
Console.WriteLine("Cannot parse a null string.")
Catch e As FormatException
Console.WriteLine("Cannot parse '{0}'.", value)
End Try
Next
Console.WriteLine()
' Parse strings using the Boolean.TryParse method.
For Each value In values
Dim flag As Boolean = False
If Boolean.TryParse(value, flag) Then
Console.WriteLine("'{0}' --> {1}", value, flag)
Else
Console.WriteLine("Cannot parse '{0}'.", value)
End If
Next
End Sub
End Module
' The example displays the following output:
' Cannot parse a null string.
' Cannot parse ''.
' 'True' --> True
' 'False' --> False
' 'true' --> True
' 'false' --> False
' ' true ' --> True
' 'TrUe' --> True
' 'fAlSe' --> False
' Cannot parse 'fa lse'.
' Cannot parse '0'.
' Cannot parse '1'.
' Cannot parse '-1'.
' Cannot parse 'string'.
'
' Unable to parse ''
' Unable to parse ''
' 'True' --> True
' 'False' --> False
' 'true' --> True
' 'false' --> False
' ' true ' --> True
' 'TrUe' --> True
' 'fAlSe' --> False
' Cannot parse 'fa lse'.
' Unable to parse '0'
' Unable to parse '1'
' Unable to parse '-1'
' Unable to parse 'string'
Visual Basic'te programlama kullanıyorsanız, bir sayının CBool dize gösterimini Boole değerine dönüştürmek için işlevini kullanabilirsiniz. "0" değerine dönüştürülür falseve sıfır olmayan herhangi bir değerin dize gösterimine truedönüştürülür. Visual Basic'te programlama çalışmıyorsanız, sayısal dizenizi Boole değerine dönüştürmeden önce sayıya dönüştürmeniz gerekir. Aşağıdaki örnek, bir tamsayı dizisini Boole değerlerine dönüştürerek bunu gösterir.
using System;
public class Example8
{
public static void Main()
{
String[] values = { "09", "12.6", "0", "-13 " };
foreach (var value in values) {
bool success, result;
int number;
success = Int32.TryParse(value, out number);
if (success) {
// The method throws no exceptions.
result = Convert.ToBoolean(number);
Console.WriteLine("Converted '{0}' to {1}", value, result);
}
else {
Console.WriteLine("Unable to convert '{0}'", value);
}
}
}
}
// The example displays the following output:
// Converted '09' to True
// Unable to convert '12.6'
// Converted '0' to False
// Converted '-13 ' to True
open System
let values = [ "09"; "12.6"; "0"; "-13 " ]
for value in values do
match Int32.TryParse value with
| true, number ->
// The method throws no exceptions.
let result = Convert.ToBoolean number
printfn $"Converted '{value}' to {result}"
| false, _ ->
printfn $"Unable to convert '{value}'"
// The example displays the following output:
// Converted '09' to True
// Unable to convert '12.6'
// Converted '0' to False
// Converted '-13 ' to True
Module Example8
Public Sub Main()
Dim values() As String = {"09", "12.6", "0", "-13 "}
For Each value In values
Dim success, result As Boolean
Dim number As Integer
success = Int32.TryParse(value, number)
If success Then
' The method throws no exceptions.
result = Convert.ToBoolean(number)
Console.WriteLine("Converted '{0}' to {1}", value, result)
Else
Console.WriteLine("Unable to convert '{0}'", value)
End If
Next
End Sub
End Module
' The example displays the following output:
' Converted '09' to True
' Unable to convert '12.6'
' Converted '0' to False
' Converted '-13 ' to True
Boole değerlerini karşılaştırma
Boole değerleri true veya falseolduğundan, bir örneğin belirtilen değerden büyük, küçük veya buna eşit olup olmadığını gösteren yöntemini açıkça çağırmak CompareTo için çok az neden vardır. Genellikle iki Boole değişkenini karşılaştırmak için yöntemini çağırır Equals veya dilinizin eşitlik işlecini kullanırsınız.
Ancak, bir Boole değişkenini sabit Boole değeri veya falseile karşılaştırmak istediğinizde, boole değerini true değerlendirmenin sonucu bu Boole değeri olduğundan, açık bir karşılaştırma yapmanız gerekmez. Örneğin, aşağıdaki iki ifade eşdeğerdir, ancak ikincisi daha küçüktür. Ancak her iki teknik de benzer performans sunar.
if (booleanValue == true) {
if booleanValue = true then
If booleanValue = True Then
if (booleanValue) {
if booleanValue then
If booleanValue Then
Boolean'larla ikili değer olarak çalışma
Boole değeri, aşağıdaki örnekte gösterildiği gibi bir bayt bellek kaplar. C# örneği anahtarla /unsafe derlenmelidir.
using System;
public struct BoolStruct
{
public bool flag1;
public bool flag2;
public bool flag3;
public bool flag4;
public bool flag5;
}
public class Example9
{
public static void Main()
{
unsafe {
BoolStruct b = new BoolStruct();
bool* addr = (bool*) &b;
Console.WriteLine("Size of BoolStruct: {0}", sizeof(BoolStruct));
Console.WriteLine("Field offsets:");
Console.WriteLine(" flag1: {0}", (bool*) &b.flag1 - addr);
Console.WriteLine(" flag1: {0}", (bool*) &b.flag2 - addr);
Console.WriteLine(" flag1: {0}", (bool*) &b.flag3 - addr);
Console.WriteLine(" flag1: {0}", (bool*) &b.flag4 - addr);
Console.WriteLine(" flag1: {0}", (bool*) &b.flag5 - addr);
}
}
}
// The example displays the following output:
// Size of BoolStruct: 5
// Field offsets:
// flag1: 0
// flag1: 1
// flag1: 2
// flag1: 3
// flag1: 4
#nowarn "9" "51"
open FSharp.NativeInterop
[<Struct>]
type BoolStruct =
val flag1: bool
val flag2: bool
val flag3: bool
val flag4: bool
val flag5: bool
let inline nint addr = NativePtr.toNativeInt addr
let mutable b = BoolStruct()
let addr = &&b
printfn $"Size of BoolStruct: {sizeof<BoolStruct>}"
printfn "Field offsets:"
printfn $" flag1: {nint &&b.flag1 - nint addr}"
printfn $" flag2: {nint &&b.flag2 - nint addr}"
printfn $" flag3: {nint &&b.flag3 - nint addr}"
printfn $" flag4: {nint &&b.flag4 - nint addr}"
printfn $" flag5: {nint &&b.flag5 - nint addr}"
// The example displays the following output:
// Size of BoolStruct: 5
// Field offsets:
// flag1: 0
// flag1: 1
// flag1: 2
// flag1: 3
// flag1: 4
Bayt düşük sıralı bit değeri temsil etmek için kullanılır. 1 değeri öğesini temsil eder true; 0 değeri değerini temsil eder false.
İpucu
Boole değer kümeleriyle çalışmak için yapısını kullanabilirsiniz System.Collections.Specialized.BitVector32 .
Yöntemini çağırarak boole değerini ikili gösterimine BitConverter.GetBytes(Boolean) dönüştürebilirsiniz. yöntemi, tek bir öğeye sahip bir bayt dizisi döndürür. Boole değerini ikili gösteriminden geri yüklemek için yöntemini çağırabilirsiniz BitConverter.ToBoolean(Byte[], Int32) .
Aşağıdaki örnek, boole değerini ikili gösterimine dönüştürmek için yöntemini çağırır BitConverter.GetBytes ve değerin tek tek bitlerini görüntüler ve ardından ikili gösteriminden değeri geri yüklemek için yöntemini çağırır BitConverter.ToBoolean .
using System;
public class Example1
{
public static void Main()
{
bool[] flags = { true, false };
foreach (var flag in flags)
{
// Get binary representation of flag.
Byte value = BitConverter.GetBytes(flag)[0];
Console.WriteLine("Original value: {0}", flag);
Console.WriteLine("Binary value: {0} ({1})", value,
GetBinaryString(value));
// Restore the flag from its binary representation.
bool newFlag = BitConverter.ToBoolean(new Byte[] { value }, 0);
Console.WriteLine("Restored value: {0}\n", flag);
}
}
private static string GetBinaryString(Byte value)
{
string retVal = Convert.ToString(value, 2);
return new string('0', 8 - retVal.Length) + retVal;
}
}
// The example displays the following output:
// Original value: True
// Binary value: 1 (00000001)
// Restored value: True
//
// Original value: False
// Binary value: 0 (00000000)
// Restored value: False
open System
let getBinaryString (value: byte) =
let retValue = Convert.ToString(value, 2)
String('0', 8 - retValue.Length) + retValue
let flags = [ true; false ]
for flag in flags do
// Get binary representation of flag.
let value = BitConverter.GetBytes(flag)[0];
printfn $"Original value: {flag}"
printfn $"Binary value: {value} ({getBinaryString value})"
// Restore the flag from its binary representation.
let newFlag = BitConverter.ToBoolean([|value|], 0)
printfn $"Restored value: {newFlag}\n"
// The example displays the following output:
// Original value: True
// Binary value: 1 (00000001)
// Restored value: True
//
// Original value: False
// Binary value: 0 (00000000)
// Restored value: False
Module Example1
Public Sub Main()
Dim flags() As Boolean = {True, False}
For Each flag In flags
' Get binary representation of flag.
Dim value As Byte = BitConverter.GetBytes(flag)(0)
Console.WriteLine("Original value: {0}", flag)
Console.WriteLine("Binary value: {0} ({1})", value,
GetBinaryString(value))
' Restore the flag from its binary representation.
Dim newFlag As Boolean = BitConverter.ToBoolean({value}, 0)
Console.WriteLine("Restored value: {0}", flag)
Console.WriteLine()
Next
End Sub
Private Function GetBinaryString(value As Byte) As String
Dim retVal As String = Convert.ToString(value, 2)
Return New String("0"c, 8 - retVal.Length) + retVal
End Function
End Module
' The example displays the following output:
' Original value: True
' Binary value: 1 (00000001)
' Restored value: True
'
' Original value: False
' Binary value: 0 (00000000)
' Restored value: False
Boole değerleriyle işlem gerçekleştirme
Bu bölümde Boole değerlerinin uygulamalarda nasıl kullanıldığı gösterilmektedir. İlk bölümde bayrak olarak kullanımı ele alınmıştır. İkincisi, aritmetik işlemler için kullanımını gösterir.
Bayrak olarak Boole değerleri
Boole değişkenleri, bazı koşulların varlığına veya yokluğuna işaret etmek için en yaygın olarak bayrak olarak kullanılır. Örneğin, yönteminde String.Compare(String, String, Boolean) , son parametresi, ignoreCaseiki dizenin karşılaştırılmasının büyük/küçük harfe duyarlıignoreCase ( ) trueveya büyük/küçük harfe duyarlı (ignoreCase ) olup olmadığını gösteren bir bayraktır false. Bayrağın değeri daha sonra bir koşullu deyimde değerlendirilebilir.
Aşağıdaki örnek, Boole değişkenlerinin bayrak olarak kullanımını göstermek için basit bir konsol uygulaması kullanır. Uygulama, çıkışın belirtilen bir dosyaya (anahtar) yeniden yönlendirilmesini ve çıkışın /f hem belirtilen bir dosyaya hem de konsola ( /b anahtar) gönderilmesini sağlayan komut satırı parametrelerini kabul eder. Uygulama, çıkışın bir dosyaya gönderilip gönderilmeymeyeceğini belirtmek için adlı isRedirected bir bayrak ve konsoluna çıkış gönderilmesi gerektiğini belirtmek için adlı isBoth bir bayrak tanımlar. F# örneği, bağımsız değişkenleri ayrıştırmak için özyinelemeli bir işlev kullanır.
using System;
using System.IO;
using System.Threading;
public class Example5
{
public static void Main()
{
// Initialize flag variables.
bool isRedirected = false;
bool isBoth = false;
String fileName = "";
StreamWriter sw = null;
// Get any command line arguments.
String[] args = Environment.GetCommandLineArgs();
// Handle any arguments.
if (args.Length > 1) {
for (int ctr = 1; ctr < args.Length; ctr++) {
String arg = args[ctr];
if (arg.StartsWith("/") || arg.StartsWith("-")) {
switch (arg.Substring(1).ToLower())
{
case "f":
isRedirected = true;
if (args.Length < ctr + 2) {
ShowSyntax("The /f switch must be followed by a filename.");
return;
}
fileName = args[ctr + 1];
ctr++;
break;
case "b":
isBoth = true;
break;
default:
ShowSyntax(String.Format("The {0} switch is not supported",
args[ctr]));
return;
}
}
}
}
// If isBoth is True, isRedirected must be True.
if (isBoth && ! isRedirected) {
ShowSyntax("The /f switch must be used if /b is used.");
return;
}
// Handle output.
if (isRedirected) {
sw = new StreamWriter(fileName);
if (!isBoth)
Console.SetOut(sw);
}
String msg = String.Format("Application began at {0}", DateTime.Now);
Console.WriteLine(msg);
if (isBoth) sw.WriteLine(msg);
Thread.Sleep(5000);
msg = String.Format("Application ended normally at {0}", DateTime.Now);
Console.WriteLine(msg);
if (isBoth) sw.WriteLine(msg);
if (isRedirected) sw.Close();
}
private static void ShowSyntax(String errMsg)
{
Console.WriteLine(errMsg);
Console.WriteLine("\nSyntax: Example [[/f <filename> [/b]]\n");
}
}
open System
open System.IO
open System.Threading
let showSyntax errMsg =
printfn $"{errMsg}\n\nSyntax: Example [[/f <filename> [/b]]\n"
let mutable isRedirected = false
let mutable isBoth = false
let mutable fileName = ""
let rec parse = function
| [] -> ()
| "-b" :: rest
| "/b" :: rest ->
isBoth <- true
// Parse remaining arguments.
parse rest
| "-f" :: file :: rest
| "/f" :: file :: rest ->
isRedirected <- true
fileName <- file
// Parse remaining arguments.
parse rest
| "-f" :: []
| "/f" :: [] ->
isRedirected <- true
// No more arguments to parse.
| x -> showSyntax $"The {x} switch is not supported"
Environment.GetCommandLineArgs()[1..]
|> List.ofArray
|> parse
// If isBoth is True, isRedirected must be True.
if isBoth && not isRedirected then
showSyntax "The /f switch must be used if /b is used."
// If isRedirected is True, a fileName must be specified.
elif fileName = "" && isRedirected then
showSyntax "The /f switch must be followed by a filename."
else
use mutable sw = null
// Handle output.
let writeLine =
if isRedirected then
sw <- new StreamWriter(fileName)
if isBoth then
fun text ->
printfn "%s" text
sw.WriteLine text
else sw.WriteLine
else printfn "%s"
writeLine $"Application began at {DateTime.Now}"
Thread.Sleep 5000
writeLine $"Application ended normally at {DateTime.Now}"
Imports System.IO
Imports System.Threading
Module Example5
Public Sub Main()
' Initialize flag variables.
Dim isRedirected, isBoth As Boolean
Dim fileName As String = ""
Dim sw As StreamWriter = Nothing
' Get any command line arguments.
Dim args() As String = Environment.GetCommandLineArgs()
' Handle any arguments.
If args.Length > 1 Then
For ctr = 1 To args.Length - 1
Dim arg As String = args(ctr)
If arg.StartsWith("/") OrElse arg.StartsWith("-") Then
Select Case arg.Substring(1).ToLower()
Case "f"
isRedirected = True
If args.Length < ctr + 2 Then
ShowSyntax("The /f switch must be followed by a filename.")
Exit Sub
End If
fileName = args(ctr + 1)
ctr += 1
Case "b"
isBoth = True
Case Else
ShowSyntax(String.Format("The {0} switch is not supported",
args(ctr)))
Exit Sub
End Select
End If
Next
End If
' If isBoth is True, isRedirected must be True.
If isBoth And Not isRedirected Then
ShowSyntax("The /f switch must be used if /b is used.")
Exit Sub
End If
' Handle output.
If isRedirected Then
sw = New StreamWriter(fileName)
If Not isBoth Then
Console.SetOut(sw)
End If
End If
Dim msg As String = String.Format("Application began at {0}", Date.Now)
Console.WriteLine(msg)
If isBoth Then sw.WriteLine(msg)
Thread.Sleep(5000)
msg = String.Format("Application ended normally at {0}", Date.Now)
Console.WriteLine(msg)
If isBoth Then sw.WriteLine(msg)
If isRedirected Then sw.Close()
End Sub
Private Sub ShowSyntax(errMsg As String)
Console.WriteLine(errMsg)
Console.WriteLine()
Console.WriteLine("Syntax: Example [[/f <filename> [/b]]")
Console.WriteLine()
End Sub
End Module
Boole'ler ve aritmetik işlemler
Boole değeri bazen matematiksel hesaplamayı tetikleyen bir koşulun varlığını göstermek için kullanılır. Örneğin, bir hasShippingCharge değişken, fatura tutarına sevkiyat ücretleri eklenip eklenmeyeceğini belirten bir bayrak görevi görür.
Değeri olan bir false işlemin bir işlemin sonucu üzerinde hiçbir etkisi olmadığından, Boole değerini matematiksel işlemde kullanılacak bir tamsayıyı değerine dönüştürmek gerekmez. Bunun yerine koşullu mantık kullanabilirsiniz.
Aşağıdaki örnek bir alt toplam, sevkiyat ücreti ve isteğe bağlı bir hizmet ücretinden oluşan bir tutarı hesaplar. Değişken, hasServiceCharge hizmet ücretinin uygulanıp uygulanmadığını belirler. Örnek, sayısal bir değere dönüştürmek hasServiceCharge ve bunu hizmet ücreti miktarıyla çarpmak yerine, varsa hizmet ücreti miktarını eklemek için koşullu mantık kullanır.
using System;
public class Example6
{
public static void Main()
{
bool[] hasServiceCharges = { true, false };
Decimal subtotal = 120.62m;
Decimal shippingCharge = 2.50m;
Decimal serviceCharge = 5.00m;
foreach (var hasServiceCharge in hasServiceCharges) {
Decimal total = subtotal + shippingCharge +
(hasServiceCharge ? serviceCharge : 0);
Console.WriteLine("hasServiceCharge = {1}: The total is {0:C2}.",
total, hasServiceCharge);
}
}
}
// The example displays output like the following:
// hasServiceCharge = True: The total is $128.12.
// hasServiceCharge = False: The total is $123.12.
let hasServiceCharges = [ true; false ]
let subtotal = 120.62M
let shippingCharge = 2.50M
let serviceCharge = 5.00M
for hasServiceCharge in hasServiceCharges do
let total =
subtotal + shippingCharge + if hasServiceCharge then serviceCharge else 0M
printfn $"hasServiceCharge = {hasServiceCharge}: The total is {total:C2}."
// The example displays output like the following:
// hasServiceCharge = True: The total is $128.12.
// hasServiceCharge = False: The total is $123.12.
Module Example6
Public Sub Main()
Dim hasServiceCharges() As Boolean = {True, False}
Dim subtotal As Decimal = 120.62D
Dim shippingCharge As Decimal = 2.5D
Dim serviceCharge As Decimal = 5D
For Each hasServiceCharge In hasServiceCharges
Dim total As Decimal = subtotal + shippingCharge +
If(hasServiceCharge, serviceCharge, 0)
Console.WriteLine("hasServiceCharge = {1}: The total is {0:C2}.",
total, hasServiceCharge)
Next
End Sub
End Module
' The example displays output like the following:
' hasServiceCharge = True: The total is $128.12.
' hasServiceCharge = False: The total is $123.12.
Boole'lar ve birlikte çalışma
Temel veri türlerini COM'a hazırlama işlemi genellikle basittir ancak Boolean veri türü bir özel durumdur. Türü aşağıdaki gösterimlerden herhangi birine sıralamak Boolean için özniteliğini uygulayabilirsinizMarshalAsAttribute:
| Numaralandırma türü | Yönetilmeyen biçim |
|---|---|
| UnmanagedType.Bool | Sıfır olmayan değerlerin ve 0'ın falsetemsil true ettiği 4 baytlık tamsayı değeri. Bu, platform çağırma çağrılarındaki bir Boolean yapıdaki ve parametredeki bir Boolean alanın varsayılan biçimidir. |
| UnmanagedType.U1 | 1 baytlık bir tamsayı değeridir; burada 1 true ve 0 değerini temsil eder false. |
| UnmanagedType.VariantBool | 2 baytlık bir tamsayı değeri; burada -1 true ve 0 değerini temsil eder false. Bu, COM birlikte çalışma çağrılarındaki bir Boolean parametrenin varsayılan biçimidir. |
Geri Bildirim
Çok yakında: 2024 boyunca, içerik için geri bildirim mekanizması olarak GitHub Sorunları’nı kullanımdan kaldıracak ve yeni bir geri bildirim sistemiyle değiştireceğiz. Daha fazla bilgi için bkz. https://aka.ms/ContentUserFeedback.
Gönderin ve geri bildirimi görüntüleyin