是否存在表示整数范围的C#类型？
我需要存储一个整数范围。在C#4.0中是否存在这种类型是否存在表示整数范围的C#类型？,c#,C#,我需要存储一个整数范围。在C#4.0中是否存在这种类型 当然，我可以用int-From和int-To属性编写我自己的类，并构建适当的逻辑，以确保From我发现最好是自己的类。有些人使用元组s或点s，但最终你希望你的范围更广泛，并提供一些与范围相关的简便方法。最好是泛型（如果您需要一个Doubles的范围，或者某个自定义类的范围），例如： /// <summary>The Range class.</summary> /// <typeparam name="T"&g
当然，我可以用
int-Fromint-ToFrom我发现最好是自己的类。有些人使用元组
s或点
s，但最终你希望你的范围
更广泛，并提供一些与范围
相关的简便方法。最好是泛型（如果您需要一个Double
s的范围，或者某个自定义类的范围），例如：
/// <summary>The Range class.</summary>
/// <typeparam name="T">Generic parameter.</typeparam>
public class Range<T> where T : IComparable<T>
{
/// <summary>Minimum value of the range.</summary>
public T Minimum { get; set; }
/// <summary>Maximum value of the range.</summary>
public T Maximum { get; set; }
/// <summary>Presents the Range in readable format.</summary>
/// <returns>String representation of the Range</returns>
public override string ToString()
{
return string.Format("[{0} - {1}]", this.Minimum, this.Maximum);
}
/// <summary>Determines if the range is valid.</summary>
/// <returns>True if range is valid, else false</returns>
public bool IsValid()
{
return this.Minimum.CompareTo(this.Maximum) <= 0;
}
/// <summary>Determines if the provided value is inside the range.</summary>
/// <param name="value">The value to test</param>
/// <returns>True if the value is inside Range, else false</returns>
public bool ContainsValue(T value)
{
return (this.Minimum.CompareTo(value) <= 0) && (value.CompareTo(this.Maximum) <= 0);
}
/// <summary>Determines if this Range is inside the bounds of another range.</summary>
/// <param name="Range">The parent range to test on</param>
/// <returns>True if range is inclusive, else false</returns>
public bool IsInsideRange(Range<T> range)
{
return this.IsValid() && range.IsValid() && range.ContainsValue(this.Minimum) && range.ContainsValue(this.Maximum);
}
/// <summary>Determines if another range is inside the bounds of this range.</summary>
/// <param name="Range">The child range to test</param>
/// <returns>True if range is inside, else false</returns>
public bool ContainsRange(Range<T> range)
{
return this.IsValid() && range.IsValid() && this.ContainsValue(range.Minimum) && this.ContainsValue(range.Maximum);
}
}
///范围类。
///泛型参数。
公共类范围，其中T:i可比较
{
///范围的最小值。
公共T最小值{get；set；}
///范围的最大值。
公共T最大值{get；set；}
///以可读格式显示范围。
///范围的字符串表示形式
公共重写字符串ToString（）
{
返回string.Format（“[{0}-{1}]”，this.Minimum，this.Maximum）；
}
///确定范围是否有效。
///如果范围有效，则为True，否则为false
公共bool是有效的（）
{
返回this.Minimum.CompareTo（this.Maximum）一个怎么样？只是我写的一个小类，可能对某人有帮助：
public class Range
{
public static List<int> range(int a, int b)
{
List<int> result = new List<int>();
for(int i = a; i <= b; i++)
{
result.Add(i);
}
return result;
}
public static int[] Understand(string input)
{
return understand(input).ToArray();
}
public static List<int> understand(string input)
{
List<int> result = new List<int>();
string[] lines = input.Split(new char[] {';', ','});
foreach (string line in lines)
{
try
{
int temp = Int32.Parse(line);
result.Add(temp);
}
catch
{
string[] temp = line.Split(new char[] { '-' });
int a = Int32.Parse(temp[0]);
int b = Int32.Parse(temp[1]);
result.AddRange(range(a, b).AsEnumerable());
}
}
return result;
}
}
结果如下：
List<int>
[0]: 1
[1]: 5
[2]: 6
[3]: 7
[4]: 8
[5]: 9
[6]: 14
[7]: 16
[8]: 17
[9]: 20
[10]: 21
[11]: 22
[12]: 23
[13]: 24
列表
[0]: 1
[1]: 5
[2]: 6
[3]: 7
[4]: 8
[5]: 9
[6]: 14
[7]: 16
[8]: 17
[9]: 20
[10]: 21
[11]: 22
[12]: 23
[13]: 24
由于我在C#中也缺少间隔，我甚至可以处理更复杂类型的间隔，例如两个日期时间之间的间隔，这涉及到计算过程中的时间跨度
示例用例，其中GUI元素表示时间间隔：
// Mockup of a GUI element and mouse position.
var timeBar = new { X = 100, Width = 200 };
int mouseX = 180;
// Find out which date on the time bar the mouse is positioned on,
// assuming it represents whole of 2014.
var timeRepresentation = new Interval<int>( timeBar.X, timeBar.X + timeBar.Width );
DateTime start = new DateTime( 2014, 1, 1 );
DateTime end = new DateTime( 2014, 12, 31 );
var thisYear = new Interval<DateTime, TimeSpan>( start, end );
DateTime hoverOver = timeRepresentation.Map( mouseX, thisYear );
// If the user clicks, zoom in to this position.
double zoomLevel = 0.5;
double zoomInAt = thisYear.GetPercentageFor( hoverOver );
Interval<DateTime, TimeSpan> zoomed = thisYear.Scale( zoomLevel, zoomInAt );
// Iterate over the interval, e.g. draw labels.
zoomed.EveryStepOf( TimeSpan.FromDays( 1 ), d => DrawLabel( d ) );
//GUI元素的模型和鼠标位置。
var timeBar=new{X=100，Width=200}；
int-mouseX=180；
//找出鼠标位于时间栏上的日期，
//假设它代表2014年全年。
var timeRepresentation=新间隔（timeBar.X，timeBar.X+timeBar.Width）；
日期时间开始=新的日期时间（2014,1,1）；
DateTime end=新的日期时间（2014年12月31日）；
var thisYear=新间隔（开始、结束）；
DateTime hoverOver=timeRepresentation.Map（mouseX，今年）；
//如果用户单击，则放大到此位置。
双zoomLevel=0.5；
双缩放=今年。GetPercentageFor（悬停）；
缩放间隔=今年。缩放（缩放级别，缩放终止）；
//迭代间隔，例如绘制标签。
zoomed.EveryStepOf（TimeSpan.FromDays（1），d=>DrawLabel（d））；
以更广泛地表示受支持的功能
在封面下，它是缓存的，因此在第一次初始化类型时只需要花费一定的成本。改进@andrius naruševičius非常有帮助的答案，使其更为惯用且易于定制
/// <summary>
/// http://stackoverflow.com/questions/5343006/is-there-a-c-sharp-type-for-representing-an-integer-range
/// </summary>
public class Range
{
readonly static char[] Separators = {','};
public static List<int> Explode(int from, int to)
{
return Enumerable.Range(from, (to-from)+1).ToList();
}
public static List<int> Interpret(string input)
{
var result = new List<int>();
var values = input.Split(Separators);
string rangePattern = @"(?<range>(?<from>\d+)-(?<to>\d+))";
var regex = new Regex(rangePattern);
foreach (string value in values)
{
var match = regex.Match(value);
if (match.Success)
{
var from = Parse(match.Groups["from"].Value);
var to = Parse(match.Groups["to"].Value);
result.AddRange(Explode(from, to));
}
else
{
result.Add(Parse(value));
}
}
return result;
}
/// <summary>
/// Split this out to allow custom throw etc
/// </summary>
private static int Parse(string value)
{
int output;
var ok = int.TryParse(value, out output);
if (!ok) throw new FormatException($"Failed to parse '{value}' as an integer");
return output;
}
}
编写一个像这样的扩展方法
public static class NumericExtentions
{
public static bool InRange(this int value, int from, int to)
{
if (value >= from && value <= to)
return true;
return false;
}
public static bool InRange(this double value, double from, double to)
{
if (value >= from && value <= to)
return true;
return false;
}
}
此实现受@drharris答案的启发，允许您使用值定义适当的数学区间，这些值可以是包含的/独占的
/// <summary>The Interval class.</summary>
/// <typeparam name="T">Generic parameter.</typeparam>
public class Interval<T> : IEquatable<Interval<T>>
where T : IComparable<T>, IEquatable<T>
{
public Interval()
{ }
public Interval(IntervalValue<T> minimum, IntervalValue<T> maximum)
{
this.Minimum = minimum;
this.Maximum = maximum;
}
/// <summary>Minimum value of the interval.</summary>
public IntervalValue<T>? Minimum { get; set; }
/// <summary>Maximum value of the interval.</summary>
public IntervalValue<T>? Maximum { get; set; }
/// <summary>Presents the Interval in readable format.</summary>
/// <returns>String representation of the Interval</returns>
public override string ToString()
{
var min = this.Minimum;
var max = this.Maximum;
var sb = new StringBuilder();
if (min.HasValue)
sb.AppendFormat(min.Value.ToString(IntervalNotationPosition.Left));
else
sb.Append("(-∞");
sb.Append(',');
if (max.HasValue)
sb.AppendFormat(max.Value.ToString(IntervalNotationPosition.Right));
else
sb.Append("∞)");
var result = sb.ToString();
return result;
}
/// <summary>Determines if the interval is valid.</summary>
/// <returns>True if interval is valid, else false</returns>
public bool IsValid()
{
var min = this.Minimum;
var max = this.Maximum;
if (min.HasValue && max.HasValue)
return min.Value.Value.CompareTo(max.Value.Value) <= 0;
return true;
}
/// <summary>Determines if the provided value is inside the interval.</summary>
/// <param name="x">The value to test</param>
/// <returns>True if the value is inside Interval, else false</returns>
public bool ContainsValue(T x)
{
if (x == null)
throw new ArgumentNullException(nameof(x));
var min = this.Minimum;
var max = this.Maximum;
var isValid = this.IsValid();
if (!isValid)
throw new InvalidOperationException("Interval is not valid.");
bool result = true; // (-∞,∞)
if (min.HasValue)
{
if (min.Value.Type == IntervalValueType.Exclusive)
result &= min.Value.Value.CompareTo(x) < 0;
else if (min.Value.Type == IntervalValueType.Inclusive)
result &= min.Value.Value.CompareTo(x) <= 0;
else
throw new NotSupportedException();
}
if (max.HasValue)
{
if (max.Value.Type == IntervalValueType.Exclusive)
result &= max.Value.Value.CompareTo(x) > 0;
else if (max.Value.Type == IntervalValueType.Inclusive)
result &= max.Value.Value.CompareTo(x) >= 0;
else
throw new NotSupportedException();
}
return result;
}
public bool Equals(Interval<T> other)
{
if (other == null)
return false;
if (ReferenceEquals(this, other))
return true;
return this.Minimum?.Equals(other.Minimum) == true
&& this.Maximum?.Equals(other.Maximum) == true;
}
public override bool Equals(object obj)
{
return this.Equals(obj as Interval<T>);
}
public override int GetHashCode()
{
unchecked
{
int hash = (int)2166136261;
hash = hash * 16777619 ^ this.Minimum?.GetHashCode() ?? 0;
hash = hash * 16777619 ^ this.Maximum?.GetHashCode() ?? 0;
return hash;
}
}
}
public struct IntervalValue<T> : IEquatable<IntervalValue<T>>
where T : IComparable<T>, IEquatable<T> //, IFormattable
{
private readonly T value;
private readonly IntervalValueType type;
public IntervalValue(T value, IntervalValueType type)
{
if (value == null)
throw new ArgumentNullException(nameof(value));
this.value = value;
this.type = type;
}
public T Value
{
get { return this.value; }
}
public IntervalValueType Type
{
get { return this.type; }
}
public bool Equals(IntervalValue<T> other)
{
return this.value.Equals(other.value)
&& this.type == other.type;
}
public override bool Equals(object obj)
{
return obj is IntervalValue<T> && this.Equals((IntervalValue<T>)obj);
}
public override int GetHashCode()
{
unchecked
{
int hash = (int)2166136261;
hash = hash * 16777619 ^ this.value.GetHashCode();
hash = hash * 16777619 ^ this.type.GetHashCode();
return hash;
}
}
internal string ToString(IntervalNotationPosition position)
{
var notation = this.Type.ToString(position);
switch (position)
{
case IntervalNotationPosition.Left:
return string.Format("{0}{1}", notation, this.Value);
case IntervalNotationPosition.Right:
return string.Format("{0}{1}", this.Value, notation);
default:
throw new NotSupportedException();
}
}
}
internal static class IntervalValueTypeExtensions
{
public static string ToString(this IntervalValueType type, IntervalNotationPosition position)
{
switch (position)
{
case IntervalNotationPosition.Left:
switch (type)
{
case IntervalValueType.Inclusive: return "[";
case IntervalValueType.Exclusive: return "(";
default:
throw new NotSupportedException();
}
case IntervalNotationPosition.Right:
switch (type)
{
case IntervalValueType.Inclusive: return "]";
case IntervalValueType.Exclusive: return ")";
default:
throw new NotSupportedException();
}
break;
default:
throw new NotSupportedException();
}
}
}
public enum IntervalValueType
{
Inclusive,
Exclusive
}
public enum IntervalNotationPosition
{
Left,
Right
}
///间隔类。
///泛型参数。
公共类间隔：IEquatable
式中T:i可比，i可比
{
公共间隔（）
{ }
公共间隔（最小值间隔、最大值间隔）
{
这个。最小值=最小值；
最大值=最大值；
}
///间隔的最小值。
公共IntervalValue？最小值{get；set；}
///间隔的最大值。
公共IntervalValue？最大值{get；set；}
///以可读格式显示间隔。
///区间的字符串表示形式
公共重写字符串ToString（）
{
var min=这个最小值；
var max=这个最大值；
var sb=新的StringBuilder（）；
如果（最小值）
sb.AppendFormat（最小值ToString（IntervalNotationPosition.Left））；
其他的
某人附加（”(-∞");
某人附加（“，”）；
如果（最大值）
sb.AppendFormat（max.Value.ToString（IntervalNotationPosition.Right））；
其他的
某人附加（”∞)");
var result=sb.ToString（）；
返回结果；
}
///确定间隔是否有效。
///如果间隔有效，则为True，否则为false
公共bool是有效的（）
{
var min=这个最小值；
var max=这个最大值；
if（最小值和最大值）
返回min.Value.Value.CompareTo（max.Value.Value）=0；
其他的
抛出新的NotSupportedException（）；
}
返回结果；
}
公共布尔等于（间隔其他）
{
如果（其他==null）
返回false；
if（ReferenceEquals（this，other））
返回true；
返回此.Minimum？等于（其他.Minimum）=true
&&此.max？等于（其他.max）==true；
}
公共覆盖布尔等于（对象对象对象）
{
返回此.Equals（obj作为间隔）；
}
公共覆盖int GetHashCode（）
{
未经检查
{
int散列=（int）2166136261；
hash=hash*16777619^this.Minimum？.GetHashCode（）？？0；
hash=hash*16777619^this.Maximum？.GetHashCode（）？？0；
返回散列；
}
}
}
public struct intervalve值：IEquatable
其中T:i可比，i可比/，i可附加
{
私有只读T值；
私有只读值类型；
公共InterValveValue（T值，InterValveValue类型）
{
如果（值==null）
抛出新ArgumentNullException（nameof（value））；
这个值=值；
this.type=type；
}
公共价值
{
获取{返回this.value；}
}
公共值间类型
{
获取{返回this.type；}
}
公共布尔等于（中间值其他）
{
归还这个
public static class NumericExtentions
{
public static bool InRange(this int value, int from, int to)
{
if (value >= from && value <= to)
return true;
return false;
}
public static bool InRange(this double value, double from, double to)
{
if (value >= from && value <= to)
return true;
return false;
}
}
if (age.InRange(18, 39))
{
//Logic
}
/// <summary>The Interval class.</summary>
/// <typeparam name="T">Generic parameter.</typeparam>
public class Interval<T> : IEquatable<Interval<T>>
where T : IComparable<T>, IEquatable<T>
{
public Interval()
{ }
public Interval(IntervalValue<T> minimum, IntervalValue<T> maximum)
{
this.Minimum = minimum;
this.Maximum = maximum;
}
/// <summary>Minimum value of the interval.</summary>
public IntervalValue<T>? Minimum { get; set; }
/// <summary>Maximum value of the interval.</summary>
public IntervalValue<T>? Maximum { get; set; }
/// <summary>Presents the Interval in readable format.</summary>
/// <returns>String representation of the Interval</returns>
public override string ToString()
{
var min = this.Minimum;
var max = this.Maximum;
var sb = new StringBuilder();
if (min.HasValue)
sb.AppendFormat(min.Value.ToString(IntervalNotationPosition.Left));
else
sb.Append("(-∞");
sb.Append(',');
if (max.HasValue)
sb.AppendFormat(max.Value.ToString(IntervalNotationPosition.Right));
else
sb.Append("∞)");
var result = sb.ToString();
return result;
}
/// <summary>Determines if the interval is valid.</summary>
/// <returns>True if interval is valid, else false</returns>
public bool IsValid()
{
var min = this.Minimum;
var max = this.Maximum;
if (min.HasValue && max.HasValue)
return min.Value.Value.CompareTo(max.Value.Value) <= 0;
return true;
}
/// <summary>Determines if the provided value is inside the interval.</summary>
/// <param name="x">The value to test</param>
/// <returns>True if the value is inside Interval, else false</returns>
public bool ContainsValue(T x)
{
if (x == null)
throw new ArgumentNullException(nameof(x));
var min = this.Minimum;
var max = this.Maximum;
var isValid = this.IsValid();
if (!isValid)
throw new InvalidOperationException("Interval is not valid.");
bool result = true; // (-∞,∞)
if (min.HasValue)
{
if (min.Value.Type == IntervalValueType.Exclusive)
result &= min.Value.Value.CompareTo(x) < 0;
else if (min.Value.Type == IntervalValueType.Inclusive)
result &= min.Value.Value.CompareTo(x) <= 0;
else
throw new NotSupportedException();
}
if (max.HasValue)
{
if (max.Value.Type == IntervalValueType.Exclusive)
result &= max.Value.Value.CompareTo(x) > 0;
else if (max.Value.Type == IntervalValueType.Inclusive)
result &= max.Value.Value.CompareTo(x) >= 0;
else
throw new NotSupportedException();
}
return result;
}
public bool Equals(Interval<T> other)
{
if (other == null)
return false;
if (ReferenceEquals(this, other))
return true;
return this.Minimum?.Equals(other.Minimum) == true
&& this.Maximum?.Equals(other.Maximum) == true;
}
public override bool Equals(object obj)
{
return this.Equals(obj as Interval<T>);
}
public override int GetHashCode()
{
unchecked
{
int hash = (int)2166136261;
hash = hash * 16777619 ^ this.Minimum?.GetHashCode() ?? 0;
hash = hash * 16777619 ^ this.Maximum?.GetHashCode() ?? 0;
return hash;
}
}
}
public struct IntervalValue<T> : IEquatable<IntervalValue<T>>
where T : IComparable<T>, IEquatable<T> //, IFormattable
{
private readonly T value;
private readonly IntervalValueType type;
public IntervalValue(T value, IntervalValueType type)
{
if (value == null)
throw new ArgumentNullException(nameof(value));
this.value = value;
this.type = type;
}
public T Value
{
get { return this.value; }
}
public IntervalValueType Type
{
get { return this.type; }
}
public bool Equals(IntervalValue<T> other)
{
return this.value.Equals(other.value)
&& this.type == other.type;
}
public override bool Equals(object obj)
{
return obj is IntervalValue<T> && this.Equals((IntervalValue<T>)obj);
}
public override int GetHashCode()
{
unchecked
{
int hash = (int)2166136261;
hash = hash * 16777619 ^ this.value.GetHashCode();
hash = hash * 16777619 ^ this.type.GetHashCode();
return hash;
}
}
internal string ToString(IntervalNotationPosition position)
{
var notation = this.Type.ToString(position);
switch (position)
{
case IntervalNotationPosition.Left:
return string.Format("{0}{1}", notation, this.Value);
case IntervalNotationPosition.Right:
return string.Format("{0}{1}", this.Value, notation);
default:
throw new NotSupportedException();
}
}
}
internal static class IntervalValueTypeExtensions
{
public static string ToString(this IntervalValueType type, IntervalNotationPosition position)
{
switch (position)
{
case IntervalNotationPosition.Left:
switch (type)
{
case IntervalValueType.Inclusive: return "[";
case IntervalValueType.Exclusive: return "(";
default:
throw new NotSupportedException();
}
case IntervalNotationPosition.Right:
switch (type)
{
case IntervalValueType.Inclusive: return "]";
case IntervalValueType.Exclusive: return ")";
default:
throw new NotSupportedException();
}
break;
default:
throw new NotSupportedException();
}
}
}
public enum IntervalValueType
{
Inclusive,
Exclusive
}
public enum IntervalNotationPosition
{
Left,
Right
}
string[] names =
{
"Archimedes", "Pythagoras", "Euclid", "Socrates", "Plato"
};
foreach (var name in names[1..4])
{
yield return name;
}