System Namespace Reference

Namespaces

 BoxedValueDetail
 
 Collections
 
 ComponentModel
 
 Constraints
 
 Data
 
 Diagnostics
 
 Drawing
 
 Globalization
 
 IO
 
 Net
 
 Reflection
 
 Resources
 
 Runtime
 
 Security
 
 StringExtra
 
 TestPredicates
 
 Text
 
 Threading
 
 Timers
 
 TypeCodeHelper
 
 Web
 
 Windows
 
 Xml
 

Classes

class  Array
 
class  ArrayPtr
 
class  AsposeCppLibrary
 
class  Attribute
 
class  BaseTypesInfo
 
class  BaseTypesInfo< FirstType, BaseTypes... >
 
class  BaseTypesInfo<>
 
class  BitConverter
 
class  BoxedEnum
 
class  BoxedValue
 
class  BoxedValue< System::Collections::Generic::KeyValuePair< TKey, TValue > >
 
class  BoxedValue< System::Drawing::Color >
 
class  BoxedValue< System::Drawing::Point >
 
class  BoxedValue< System::Drawing::PointF >
 
class  BoxedValue< System::Drawing::Rectangle >
 
class  BoxedValue< System::Drawing::RectangleF >
 
class  BoxedValue< System::Drawing::Size >
 
class  BoxedValue< System::Drawing::SizeF >
 
class  BoxedValueBase
 
class  Buffer
 
struct  CastResult
 
struct  CastResult< Array< TTo > >
 
struct  CastResult< MulticastDelegate< T > >
 
struct  CastResult< String >
 
class  Char
 
struct  CollectionAssertHelper
 
class  Comparison
 
class  Console
 
class  ConsoleOutput
 
struct  Convert
 
class  DateTime
 
class  DBNull
 
class  Decimal
 
class  DefaultBoxedValue
 
class  Delegate
 
class  Delegate< ReturnType(ArgumentTypes...)>
 
struct  EmptyArrayInitializer
 
struct  Enum
 
struct  EnumGetNameHelper
 
struct  EnumGetNameHelper< E, typename EnumMetaInfo< E >::Flags >
 
class  EnumValues
 
class  EnumValuesBase
 
struct  Environment
 
class  EventArgs
 
class  EventHandler
 
class  Exception
 
class  Func
 
class  GC
 
class  Guid
 
class  IAsyncResult
 
class  ICloneable
 
class  IComparable
 
class  IConvertible
 Defines methods that convert the value of the implementing reference or value type to a common language runtime type that has an equivalent value. More...
 
class  ICustomFormatter
 
class  IDisposable
 
class  IEnum
 
class  IEnumerableAdapter
 
class  IEnumeratorIterator
 
class  IEquatable
 
class  IFormatProvider
 
struct  IsBoxable
 
struct  IsBoxable< Collections::Generic::KeyValuePair< TKey, TValue > >
 
struct  IsBoxable< DateTime >
 
struct  IsBoxable< Decimal >
 
struct  IsBoxable< Drawing::Color >
 
struct  IsBoxable< Drawing::Point >
 
struct  IsBoxable< Drawing::PointF >
 
struct  IsBoxable< Drawing::Rectangle >
 
struct  IsBoxable< Drawing::RectangleF >
 
struct  IsBoxable< Drawing::Size >
 
struct  IsBoxable< Drawing::SizeF >
 
struct  IsBoxable< Guid >
 
struct  IsBoxable< Nullable< T > >
 
struct  IsBoxable< String >
 
struct  IsBoxable< TimeSpan >
 
struct  IsBoxable< ValueType >
 
struct  IsBoxedValue
 
struct  IsBoxedValue< BoxedValue< T > >
 
struct  IsNonConstStringArray
 
struct  IsNullable
 
struct  IsSharedPtr
 
struct  IsStringByteSequence
 
struct  IsStringLiteral
 
struct  IsStringPointer
 
class  LockContext
 
class  MarshalByRefObject
 
struct  Math
 
struct  MethodArgumentTuple
 
struct  MethodArgumentTuple< R(C::*)(Args...)>
 
class  MulticastDelegate
 
class  MulticastDelegate< ReturnType(ArgumentTypes...)>
 
class  Nullable
 
class  Object
 
class  ObjectExt
 
class  ObjectHolder
 
class  OperatingSystem
 
class  Random
 
struct  ScopeGuard
 
class  SharedPtr
 
struct  static_holder
 
class  String
 
class  StringComparer
 
class  StringHashCompiletime
 
class  StringHashCompiletime< 0 >
 
struct  TestCompare
 
struct  TestTools
 
struct  TestToolsExt
 
class  TimeSpan
 
class  TimeZone
 
class  TimeZoneInfo
 
class  TypeInfo
 
struct  TypeInfoPtr
 
class  Uri
 
class  UriBuilder
 
class  ValueType
 
class  Version
 
class  WeakPtr
 
class  WeakPtrBase
 
class  WeakPtrCounter
 

Typedefs

template<class... Args>
using Action = MulticastDelegate< void(Args...)>
 
typedef System::ArrayPtr< uint8_t > ByteArrayPtr
 
typedef std::function< void(SharedPtr< IAsyncResult >)> AsyncCallback
 
template<class TInput , class TOutput >
using Converter = MulticastDelegate< TOutput(TInput)>
 
template<class... Args>
using Event = MulticastDelegate< Args... >
 
typedef SharedPtr< EventArgsEventArgsPtr
 
typedef SharedPtr< IAsyncResultIAsyncResultPtr
 
template<class T >
using Predicate = MulticastDelegate< bool(T)>
 
typedef SharedPtr< StringComparerStringComparerPtr
 
typedef SharedPtr< TimeZoneTimeZonePtr
 
typedef SharedPtr< TimeZoneInfoTimeZoneInfoPtr
 
template<class T >
using IsWeakPtr = System::detail::is_a< T, System::WeakPtr >
 

Enumerations

enum  Base64FormattingOptions { Base64FormattingOptions::None = 0, Base64FormattingOptions::InsertLineBreaks = 1 }
 
enum  DateTimeKind { DateTimeKind::Unspecified, DateTimeKind::Utc, DateTimeKind::Local }
 
enum  DayOfWeek : int {
  DayOfWeek::Sunday = 0, DayOfWeek::Monday, DayOfWeek::Tuesday, DayOfWeek::Wednesday,
  DayOfWeek::Thursday, DayOfWeek::Friday, DayOfWeek::Saturday
}
 
enum  EnvironmentVariableTarget { Process = 0, User = 1, Machine = 2 }
 
enum  MidpointRounding { MidpointRounding::ToEven, MidpointRounding::AwayFromZero }
 
enum  PlatformID {
  PlatformID::Win32S = 0, PlatformID::Win32Windows = 1, PlatformID::Win32NT = 2, PlatformID::WinCE = 3,
  PlatformID::Unix = 4, PlatformID::Xbox = 5, PlatformID::MacOSX = 6
}
 
enum  StringSplitOptions { StringSplitOptions::None = 0, StringSplitOptions::RemoveEmptyEntries = 1 }
 
enum  StringComparison {
  StringComparison::CurrentCulture = 0, StringComparison::CurrentCultureIgnoreCase = 1, StringComparison::InvariantCulture = 2, StringComparison::InvariantCultureIgnoreCase = 3,
  StringComparison::Ordinal = 4, StringComparison::OrdinalIgnoreCase = 5
}
 
enum  TimeSpanStyles { TimeSpanStyles::None = 0x00000000, TimeSpanStyles::AssumeNegative = 0x00000001 }
 
enum  TypeCode {
  TypeCode::Empty = 0, TypeCode::Object = 1, TypeCode::DBNull = 2, TypeCode::Boolean = 3,
  TypeCode::Char = 4, TypeCode::SByte = 5, TypeCode::Byte = 6, TypeCode::Int16 = 7,
  TypeCode::UInt16 = 8, TypeCode::Int32 = 9, TypeCode::UInt32 = 10, TypeCode::Int64 = 11,
  TypeCode::UInt64 = 12, TypeCode::Single = 13, TypeCode::Double = 14, TypeCode::Decimal = 15,
  TypeCode::DateTime = 16, TypeCode::String = 18
}
 Specifies the type of an object. More...
 
enum  UriHostNameType {
  UriHostNameType::Unknown = 0, UriHostNameType::Basic = 1, UriHostNameType::Dns = 2, UriHostNameType::IPv4 = 3,
  UriHostNameType::IPv6 = 4
}
 
enum  UriKind { UriKind::RelativeOrAbsolute = 0, UriKind::Absolute = 1, UriKind::Relative = 2 }
 
enum  UriComponents {
  UriComponents::Scheme = 1, UriComponents::UserInfo = 2, UriComponents::Host = 4, UriComponents::Port = 8,
  UriComponents::SchemeAndServer = 13, UriComponents::Path = 16, UriComponents::Query = 32, UriComponents::PathAndQuery = 48,
  UriComponents::HttpRequestUrl = 61, UriComponents::Fragment = 64, UriComponents::AbsoluteUri = 127, UriComponents::StrongPort = 128,
  UriComponents::HostAndPort = 132, UriComponents::StrongAuthority = 134, UriComponents::KeepDelimiter = 1073741824
}
 
enum  UriFormat { UriFormat::UriEscaped = 1, UriFormat::Unescaped = 2, UriFormat::SafeUnescaped = 3 }
 
enum  UriPartial { UriPartial::Scheme = 0, UriPartial::Authority = 1, UriPartial::Path = 2, UriPartial::Query = 3 }
 

Functions

template<typename T >
ArrayPtr< T > MakeArray (std::initializer_list< T > init)
 
template<class T , class ... Args>
ArrayPtr< T > MakeArray (Args &&... args)
 
template<class X >
bool operator== (ArrayPtr< X > const &x, std::nullptr_t)
 
template<class X >
bool operator== (std::nullptr_t, ArrayPtr< X > const &x)
 
template<class X >
bool operator!= (ArrayPtr< X > const &x, std::nullptr_t)
 
template<class X >
bool operator!= (std::nullptr_t, ArrayPtr< X > const &x)
 
int operator- (DayOfWeek a, DayOfWeek b)
 
bool operator!= (std::nullptr_t, DateTime &)
 
bool operator< (std::nullptr_t, DateTime &)
 
bool operator<= (std::nullptr_t, DateTime &)
 
bool operator> (std::nullptr_t, DateTime &)
 
bool operator>= (std::nullptr_t, DateTime &)
 
template<typename T , typename _ = typename std::enable_if<std::is_arithmetic<T>::value>::type>
Decimal operator+ (const T &x, const Decimal &d)
 
template<typename T , typename _ = typename std::enable_if<std::is_arithmetic<T>::value>::type>
Decimal operator- (const T &x, const Decimal &d)
 
template<typename T , typename _ = typename std::enable_if<std::is_arithmetic<T>::value>::type>
Decimal operator* (const T &x, const Decimal &d)
 
template<typename T , typename _ = typename std::enable_if<std::is_arithmetic<T>::value>::type>
Decimal operator/ (const T &x, const Decimal &d)
 
void PrintTo (const Decimal &d, ::std::ostream *os)
 
template<typename T >
const std::enable_if< IsBoxable< T >::value &&!IsException< T >::value, T & >::type Default ()
 
template<typename T >
const std::enable_if< IsException< T >::value, T & >::type Default ()
 
template<typename T >
const std::enable_if<!IsBoxable< T >::value &&!IsException< T >::value &&!IsSharedPtr< T >::value, System::SharedPtr< T > & >::type Default ()
 
template<typename T >
const std::enable_if<!IsBoxable< T >::value &&!IsException< T >::value &&IsSharedPtr< T >::value, T & >::type Default ()
 
template<typename T , typename F >
std::enable_if_t< Details::is_lambda_void_void< T >::value > DoTryFinally (T &&tryBlock, F &&finallyBlock)
 
template<typename T , typename F >
std::enable_if_t< Details::is_lambda_void_boolref< T >::value, bool > DoTryFinally (T &&tryBlock, F &&finallyBlock)
 
template<typename T , typename F >
std::enable_if_t< Details::is_lambda_nonovoid_boolref< T >::value, std::experimental::optional< std::result_of_t< T(bool &)> > > DoTryFinally (T &&tryBlock, F &&finallyBlock)
 
template<typename Rs , typename F >
void DoUsingImpl (const Rs &resource, F &&usingBlock)
 
template<typename Rs , typename F >
std::enable_if_t< Details::is_lambda_void_void< F >::value > DoUsing (const Rs &resource, F &&usingBlock)
 
template<typename Rs , typename F >
std::enable_if_t< Details::is_lambda_void_arg< F, Rs >::value > DoUsing (const Rs &resource, F &&usingBlock)
 
template<typename Rs , typename F >
std::enable_if_t< Details::is_lambda_void_boolref< F >::value, bool > DoUsingWithReturn (const Rs &resource, F &&usingBlock)
 
template<typename Rs , typename F , typename RV = std::result_of_t<F(bool&)>>
std::enable_if_t< Details::is_lambda_nonovoid_boolref< F >::value, std::experimental::optional< RV > > DoUsingWithReturn (const Rs &resource, F &&usingBlock)
 
template<typename Rs , typename F >
std::enable_if_t< Details::is_lambda_void_bool_arg< F, Rs >::value, bool > DoUsingWithReturn (const Rs &resource, F &&usingBlock)
 
template<typename Rs , typename F , typename RV = std::result_of_t<F(bool&, const Rs&)>>
std::enable_if_t< Details::is_lambda_nonvoid_bool_arg< F, Rs >::value, std::experimental::optional< RV > > DoUsingWithReturn (const Rs &resource, F &&usingBlock)
 
template<typename Rs , typename F , typename... Acq>
void DoUsingMultiple (F &&usingBlock, Acq &&... acqs)
 
template<typename Rs , typename F , typename... Acq>
bool DoUsingMultipleWithVoidReturn (F &&usingBlock, Acq &&... acqs)
 
template<typename Rs , typename Rv , typename F , typename... Acq>
std::experimental::optional< Rv > DoUsingMultipleWithValueReturn (F &&usingBlock, Acq &&... acqs)
 
template<class E >
bool HasFlag (E value, E mask)
 
template<typename T >
std::enable_if< std::is_scalar< T >::value &&sizeof(T)==sizeof(int64_t), int >::type GetHashCode (const T &obj)
 
template<typename T >
std::enable_if< std::is_scalar< T >::value &&sizeof(T)==sizeof(int32_t), int >::type GetHashCode (const T &obj)
 
template<typename T >
std::enable_if< std::is_scalar< T >::value &&sizeof(T) !=sizeof(int32_t) &&sizeof(T) !=sizeof(int64_t), int >::type GetHashCode (const T &obj)
 
template<typename T >
std::enable_if<!std::is_scalar< T >::value &&(System::IsSharedPtr< T >::value||System::IsWeakPtr< T >::value), int >::type GetHashCode (const T &obj)
 
template<typename T >
std::enable_if<!std::is_scalar< T >::value &&!System::IsSharedPtr< T >::value &&!System::IsWeakPtr< T >::value, int >::type GetHashCode (const T &obj)
 
template<>
int GetHashCode (const std::thread::id &id)
 
template<typename T >
std::enable_if< IsNullable< T >::value, bool >::type operator!= (std::nullptr_t, const T &other)
 
template<typename T >
std::enable_if< IsNullable< T >::value, bool >::type operator> (std::nullptr_t, const T &)
 
template<typename T >
std::enable_if< IsNullable< T >::value, bool >::type operator< (std::nullptr_t, const T &)
 
template<typename T >
std::enable_if< IsNullable< T >::value, bool >::type operator>= (std::nullptr_t, const T &)
 
template<typename T >
std::enable_if< IsNullable< T >::value, bool >::type operator<= (std::nullptr_t, const T &)
 
template<typename T1 , typename T2 >
std::enable_if<!IsNullable< T1 >::value &&IsNullable< T2 >::value, bool >::type operator== (const T1 &some, const T2 &other)
 
template<typename T1 , typename T2 >
std::enable_if<!IsNullable< T1 >::value &&IsNullable< T2 >::value, bool >::type operator!= (const T1 &some, const T2 &other)
 
template<typename T1 , typename T2 >
std::enable_if<!IsNullable< T1 >::value &&IsNullable< T2 >::value, bool >::type operator> (const T1 &some, const T2 &other)
 
template<typename T1 , typename T2 >
std::enable_if<!IsNullable< T1 >::value &&IsNullable< T2 >::value, bool >::type operator< (const T1 &some, const T2 &other)
 
template<typename T1 , typename T2 >
std::enable_if<!IsNullable< T1 >::value &&IsNullable< T2 >::value, bool >::type operator>= (const T1 &some, const T2 &other)
 
template<typename T1 , typename T2 >
std::enable_if<!IsNullable< T1 >::value &&IsNullable< T2 >::value, bool >::type operator<= (const T1 &some, const T2 &other)
 
template<typename T >
std::enable_if<!IsNullable< T >::value &&std::is_class< T >::value, Nullable< T > >::type operator+ (std::nullptr_t, const T &)
 
template<typename T >
std::enable_if< IsNullable< T >::value, T >::type operator+ (std::nullptr_t, const T &)
 
template<typename T >
std::enable_if<!IsNullable< T >::value &&std::is_class< T >::value, Nullable< T > >::type operator+ (const T &, std::nullptr_t)
 
template<typename T >
std::enable_if< IsNullable< T >::value, T >::type operator+ (const T &, std::nullptr_t)
 
template<typename T1 , typename T2 , typename = typename std::enable_if<!IsNullable<T1>::value, int>::type, typename = typename std::enable_if<IsNullable<T2>::value, int>::type>
auto operator+ (const T1 &some, const T2 &other) -> System::Nullable< decltype(some+other.get_Value())>
 
template<typename T1 , typename T2 , typename = typename std::enable_if<!IsNullable<T1>::value, int>::type, typename = typename std::enable_if<IsNullable<T2>::value, int>::type>
auto operator- (const T1 &some, const T2 &other) -> System::Nullable< decltype(some - other.get_Value())>
 
template<typename T >
System::SharedPtr< T > meta_lock_best_cast (const System::WeakPtr< T > &from)
 
template<typename T >
System::SharedPtr< T > & meta_lock_best_cast (System::SharedPtr< T > &from)
 
template<typename T >
SharedPtr< ObjectMemberwiseClone (T *ptr)
 
template<typename TA , typename TB >
bool Equals (const TA &a, const TB &b)
 
template<>
bool Equals< float, float > (const float &a, const float &b)
 
template<>
bool Equals< double, double > (const double &a, const double &b)
 
template<typename TA , typename TB >
int Compare (const TA &a, const TB &b)
 
template<typename T >
bool IsNaN (const T &value)
 
template<typename T >
bool IsInfinity (const T &value)
 
template<typename T >
bool IsPositiveInfinity (const T &value)
 
template<typename T >
bool IsNegativeInfinity (const T &value)
 
template<typename TTo , typename TFrom >
TTo CheckedCast (TFrom value)
 
template<typename F >
ScopeGuard< F > MakeScopeGuard (F f)
 
template<typename T , typename T2 >
setter_wrap (void(*pSetter)(T2), T value)
 
template<typename T , typename T2 , typename Host >
setter_wrap (Host *const host, void(Host::*pSetter)(T2), T value)
 
template<typename T >
setter_increment_wrap (T(*pGetter)(), void(*pSetter)(T))
 
template<typename T , typename Host >
setter_increment_wrap (Host *const host, T(Host::*pGetter)(), void(Host::*pSetter)(T))
 
template<typename T >
setter_post_increment_wrap (T(*pGetter)(), void(*pSetter)(T))
 
template<typename T , typename Host >
setter_post_increment_wrap (Host *const host, T(Host::*pGetter)(), void(Host::*pSetter)(T))
 
template<typename T >
setter_decrement_wrap (T(*pGetter)(), void(*pSetter)(T))
 
template<typename T , typename Host >
setter_decrement_wrap (Host *const host, T(Host::*pGetter)(), void(Host::*pSetter)(T))
 
template<typename T >
setter_post_decrement_wrap (T(*pGetter)(), void(*pSetter)(T))
 
template<typename T , typename Host >
setter_post_decrement_wrap (Host *const host, T(Host::*pGetter)(), void(Host::*pSetter)(T))
 
template<class X , class Y >
bool operator== (SharedPtr< X > x, SharedPtr< Y > y)
 
template<class X , class Y >
bool operator!= (SharedPtr< X > x, SharedPtr< Y > y)
 
template<class X >
bool operator== (SharedPtr< X > const &x, std::nullptr_t)
 
template<class X >
bool operator== (std::nullptr_t, SharedPtr< X > const &x)
 
template<class X >
bool operator!= (SharedPtr< X > const &x, std::nullptr_t)
 
template<class X >
bool operator!= (std::nullptr_t, SharedPtr< X > const &x)
 
template<class T >
std::enable_if<!std::is_scalar< T >::value &&!std::is_pointer< T >::value &&!std::is_array< T >::value, bool >::type operator== (T const &x, std::nullptr_t)
 
template<class T >
std::enable_if<!std::is_scalar< T >::value &&!std::is_pointer< T >::value &&!std::is_array< T >::value, bool >::type operator== (std::nullptr_t, T const &x)
 
template<class X >
SharedPtr< X > MakeSharedPtr (X *p)
 
template<class X >
SharedPtr< X > MakeSharedPtr (const X *p)
 
template<class Y , class X >
SharedPtr< Y > static_pointer_cast (SharedPtr< X > const &x)
 
template<class Y , class X >
SharedPtr< Y > dynamic_pointer_cast (SharedPtr< X > const &x)
 
template<class Y , class X >
SharedPtr< Y > const_pointer_cast (SharedPtr< X > const &x)
 
template<class T , class ... Args>
std::enable_if<!IsSharedPtr< T >::value, SharedPtr< T > >::type MakeObject (Args &&... args)
 
template<class T , class ... Args>
std::enable_if< IsSharedPtr< T >::value, T >::type MakeObject (Args &&... args)
 
template<class T >
T * get_pointer (System::SharedPtr< T > const &x)
 
template<class To , class From >
Collections::Generic::ListPtr< To > CastEnumerableTo (const From &enumerable)
 
template<class To , class From >
std::enable_if<(System::IsSharedPtr< To >::value||System::IsWeakPtr< To >::value), Collections::Generic::ListPtr< To > >::type DynamicCastEnumerableTo (const From &enumerable)
 
template<class To , class From >
std::enable_if<(!System::IsSharedPtr< To >::value &&!System::IsWeakPtr< To >::value), Collections::Generic::ListPtr< To > >::type DynamicCastEnumerableTo (const From &enumerable)
 
template<class To , class From >
SharedPtr< Array< To > > StaticCastArray (const SharedPtr< Array< From >> &from)
 
template<class To , class From >
SharedPtr< Array< To > > DynamicCastArray (const SharedPtr< Array< From >> &from)
 
template<typename T >
std::enable_if< IsStringLiteral< T, wchar_t >::value, String >::type operator+ (T &left, const String &right)
 
template<typename T >
std::enable_if< IsStringPointer< T, wchar_t >::value, String >::type operator+ (T &left, const String &right)
 
String operator+ (const wchar_t left, const String &right)
 
template<class T , typename std::enable_if< IsStringLiteral< T, wchar_t >::value >::type * = nullptr>
bool operator== (T &left, const String &right)
 
template<class T , typename std::enable_if< IsStringLiteral< T, wchar_t >::value >::type * = nullptr>
bool operator!= (T &left, const String &right)
 
bool operator== (SharedPtr< Object > left, const String &right)
 
bool operator!= (SharedPtr< Object > left, const String &right)
 
bool operator== (std::nullptr_t, const String &str)
 
bool operator!= (std::nullptr_t, const String &str)
 
void PrintTo (const System::String &value, std::ostream *os)
 
template<class X >
bool operator== (WeakPtr< X > const &x, std::nullptr_t)
 
template<class X >
bool operator== (std::nullptr_t, WeakPtr< X > const &x)
 
template<class X >
bool operator!= (WeakPtr< X > const &x, std::nullptr_t)
 
template<class X >
bool operator!= (std::nullptr_t, WeakPtr< X > const &x)
 
template<class Y , class X >
SharedPtr< Y > static_pointer_cast (const WeakPtr< X > &x)
 
template<class Y , class X >
SharedPtr< Y > dynamic_pointer_cast (const WeakPtr< X > &x)
 
template<class Y , class X >
SharedPtr< Y > const_pointer_cast (const WeakPtr< X > &x)
 

Typedef Documentation

◆ Action

template<class... Args>
using System::Action = typedef MulticastDelegate<void(Args...)>

◆ AsyncCallback

typedef std::function<void(SharedPtr<IAsyncResult>)> System::AsyncCallback

◆ ByteArrayPtr

◆ Converter

template<class TInput , class TOutput >
using System::Converter = typedef MulticastDelegate<TOutput(TInput)>

◆ Event

template<class... Args>
using System::Event = typedef MulticastDelegate<Args...>

◆ EventArgsPtr

◆ IAsyncResultPtr

◆ IsWeakPtr

template<class T >
using System::IsWeakPtr = typedef System::detail::is_a<T, System::WeakPtr>

◆ Predicate

template<class T >
using System::Predicate = typedef MulticastDelegate<bool(T)>

◆ StringComparerPtr

◆ TimeZoneInfoPtr

◆ TimeZonePtr

Enumeration Type Documentation

◆ Base64FormattingOptions

Enumerator
None 
InsertLineBreaks 

◆ DateTimeKind

enum System::DateTimeKind
strong
Enumerator
Unspecified 
Utc 
Local 

◆ DayOfWeek

enum System::DayOfWeek : int
strong
Enumerator
Sunday 
Monday 
Tuesday 
Wednesday 
Thursday 
Friday 
Saturday 

◆ EnvironmentVariableTarget

Enumerator
Process 
User 
Machine 

◆ MidpointRounding

Enumerator
ToEven 
AwayFromZero 

◆ PlatformID

enum System::PlatformID
strong
Enumerator
Win32S 
Win32Windows 
Win32NT 
WinCE 
Unix 
Xbox 
MacOSX 

◆ StringComparison

Enumerator
CurrentCulture 
CurrentCultureIgnoreCase 
InvariantCulture 
InvariantCultureIgnoreCase 
Ordinal 
OrdinalIgnoreCase 

◆ StringSplitOptions

Enumerator
None 
RemoveEmptyEntries 

◆ TimeSpanStyles

Enumerator
None 
AssumeNegative 

◆ TypeCode

enum System::TypeCode
strong

Specifies the type of an object.

Enumerator
Empty 

A null reference.

Object 

A general type representing any reference or value type not explicitly represented by another TypeCode.

DBNull 

A database null (column) value.

Boolean 

A simple type representing Boolean values of true or false.

Char 

An integral type representing unsigned 16-bit integers with values between 0 and 65535.

SByte 

An integral type representing signed 8-bit integers with values between -128 and 127.

Byte 

An integral type representing unsigned 8-bit integers with values between 0 and 255.

Int16 

An integral type representing signed 16-bit integers with values between -32768 and 32767.

UInt16 

An integral type representing unsigned 16-bit integers with values between 0 and 65535.

Int32 

An integral type representing signed 32-bit integers with values between -2147483648 and 2147483647.

UInt32 

An integral type representing unsigned 32-bit integers with values between 0 and 4294967295.

Int64 

An integral type representing signed 64-bit integers with values between -9223372036854775808 and 9223372036854775807.

UInt64 

An integral type representing unsigned 64-bit integers with values between 0 and 18446744073709551615.

Single 

A floating point type representing values ranging from approximately 1.5 x 10 -45 to 3.4 x 10 38 with a precision of 7 digits.

Double 

A floating point type representing values ranging from approximately 5.0 x 10 -324 to 1.7 x 10 308 with a precision of 15-16 digits.

Decimal 

A simple type representing values ranging from 1.0 x 10 -28 to approximately 7.9 x 10 28 with 28-29 significant digits.

DateTime 

A type representing a date and time value.

String 

A sealed class type representing Unicode character strings.

◆ UriComponents

enum System::UriComponents
strong
Enumerator
Scheme 
UserInfo 
Host 
Port 
SchemeAndServer 
Path 
Query 
PathAndQuery 
HttpRequestUrl 
Fragment 
AbsoluteUri 
StrongPort 
HostAndPort 
StrongAuthority 
KeepDelimiter 

◆ UriFormat

enum System::UriFormat
strong
Enumerator
UriEscaped 
Unescaped 
SafeUnescaped 

◆ UriHostNameType

Enumerator
Unknown 
Basic 
Dns 
IPv4 
IPv6 

◆ UriKind

enum System::UriKind
strong
Enumerator
RelativeOrAbsolute 
Absolute 
Relative 

◆ UriPartial

enum System::UriPartial
strong
Enumerator
Scheme 
Authority 
Path 
Query 

Function Documentation

◆ CastEnumerableTo()

template<class To , class From >
Collections::Generic::ListPtr<To> System::CastEnumerableTo ( const From &  enumerable)

◆ CheckedCast()

template<typename TTo , typename TFrom >
TTo System::CheckedCast ( TFrom  value)

◆ Compare()

template<typename TA , typename TB >
int System::Compare ( const TA &  a,
const TB &  b 
)
inline

◆ const_pointer_cast() [1/2]

template<class Y , class X >
SharedPtr<Y> System::const_pointer_cast ( const WeakPtr< X > &  x)

◆ const_pointer_cast() [2/2]

template<class Y , class X >
SharedPtr<Y> System::const_pointer_cast ( SharedPtr< X > const &  x)

◆ Default() [1/4]

template<typename T >
const std::enable_if<IsBoxable<T>::value && !IsException<T>::value, T&>::type System::Default ( )

◆ Default() [2/4]

template<typename T >
const std::enable_if<IsException<T>::value, T&>::type System::Default ( )

◆ Default() [3/4]

template<typename T >
const std::enable_if<!IsBoxable<T>::value && !IsException<T>::value && !IsSharedPtr<T>::value, System::SharedPtr<T>&>::type System::Default ( )

◆ Default() [4/4]

template<typename T >
const std::enable_if<!IsBoxable<T>::value && !IsException<T>::value && IsSharedPtr<T>::value, T&>::type System::Default ( )

◆ DoTryFinally() [1/3]

template<typename T , typename F >
std::enable_if_t<Details::is_lambda_void_void<T>::value> System::DoTryFinally ( T &&  tryBlock,
F &&  finallyBlock 
)

◆ DoTryFinally() [2/3]

template<typename T , typename F >
std::enable_if_t<Details::is_lambda_void_boolref<T>::value, bool> System::DoTryFinally ( T &&  tryBlock,
F &&  finallyBlock 
)

◆ DoTryFinally() [3/3]

template<typename T , typename F >
std::enable_if_t<Details::is_lambda_nonovoid_boolref<T>::value, std::experimental::optional<std::result_of_t<T(bool&)> > > System::DoTryFinally ( T &&  tryBlock,
F &&  finallyBlock 
)

◆ DoUsing() [1/2]

template<typename Rs , typename F >
std::enable_if_t<Details::is_lambda_void_void<F>::value> System::DoUsing ( const Rs &  resource,
F &&  usingBlock 
)

◆ DoUsing() [2/2]

template<typename Rs , typename F >
std::enable_if_t<Details::is_lambda_void_arg<F, Rs>::value> System::DoUsing ( const Rs &  resource,
F &&  usingBlock 
)

◆ DoUsingImpl()

template<typename Rs , typename F >
void System::DoUsingImpl ( const Rs &  resource,
F &&  usingBlock 
)

◆ DoUsingMultiple()

template<typename Rs , typename F , typename... Acq>
void System::DoUsingMultiple ( F &&  usingBlock,
Acq &&...  acqs 
)

◆ DoUsingMultipleWithValueReturn()

template<typename Rs , typename Rv , typename F , typename... Acq>
std::experimental::optional<Rv> System::DoUsingMultipleWithValueReturn ( F &&  usingBlock,
Acq &&...  acqs 
)

◆ DoUsingMultipleWithVoidReturn()

template<typename Rs , typename F , typename... Acq>
bool System::DoUsingMultipleWithVoidReturn ( F &&  usingBlock,
Acq &&...  acqs 
)

◆ DoUsingWithReturn() [1/4]

template<typename Rs , typename F >
std::enable_if_t<Details::is_lambda_void_boolref<F>::value, bool> System::DoUsingWithReturn ( const Rs &  resource,
F &&  usingBlock 
)

◆ DoUsingWithReturn() [2/4]

template<typename Rs , typename F , typename RV = std::result_of_t<F(bool&)>>
std::enable_if_t<Details::is_lambda_nonovoid_boolref<F>::value, std::experimental::optional<RV> > System::DoUsingWithReturn ( const Rs &  resource,
F &&  usingBlock 
)

◆ DoUsingWithReturn() [3/4]

template<typename Rs , typename F >
std::enable_if_t<Details::is_lambda_void_bool_arg<F,Rs>::value, bool> System::DoUsingWithReturn ( const Rs &  resource,
F &&  usingBlock 
)

◆ DoUsingWithReturn() [4/4]

template<typename Rs , typename F , typename RV = std::result_of_t<F(bool&, const Rs&)>>
std::enable_if_t<Details::is_lambda_nonvoid_bool_arg<F,Rs>::value, std::experimental::optional<RV> > System::DoUsingWithReturn ( const Rs &  resource,
F &&  usingBlock 
)

◆ dynamic_pointer_cast() [1/2]

template<class Y , class X >
SharedPtr<Y> System::dynamic_pointer_cast ( const WeakPtr< X > &  x)

◆ dynamic_pointer_cast() [2/2]

template<class Y , class X >
SharedPtr<Y> System::dynamic_pointer_cast ( SharedPtr< X > const &  x)

◆ DynamicCastArray()

template<class To , class From >
SharedPtr<Array<To> > System::DynamicCastArray ( const SharedPtr< Array< From >> &  from)

◆ DynamicCastEnumerableTo() [1/2]

template<class To , class From >
std::enable_if<(System::IsSharedPtr<To>::value || System::IsWeakPtr<To>::value), Collections::Generic::ListPtr<To> >::type System::DynamicCastEnumerableTo ( const From &  enumerable)

◆ DynamicCastEnumerableTo() [2/2]

template<class To , class From >
std::enable_if<(!System::IsSharedPtr<To>::value && !System::IsWeakPtr<To>::value), Collections::Generic::ListPtr<To> >::type System::DynamicCastEnumerableTo ( const From &  enumerable)

◆ Equals()

template<typename TA , typename TB >
bool System::Equals ( const TA &  a,
const TB &  b 
)
inline

◆ Equals< double,="" double="">()

template<>
bool System::Equals< double, double > ( const double &  a,
const double &  b 
)
inline

◆ Equals< float,="" float="">()

template<>
bool System::Equals< float, float > ( const float &  a,
const float &  b 
)
inline

◆ get_pointer()

template<class T >
T* System::get_pointer ( System::SharedPtr< T > const &  x)

◆ GetHashCode() [1/6]

template<typename T >
std::enable_if<std::is_scalar<T>::value && sizeof(T) == sizeof(int64_t), int>::type System::GetHashCode ( const T &  obj)

◆ GetHashCode() [2/6]

template<typename T >
std::enable_if<std::is_scalar<T>::value && sizeof(T) == sizeof(int32_t), int>::type System::GetHashCode ( const T &  obj)

◆ GetHashCode() [3/6]

template<typename T >
std::enable_if<std::is_scalar<T>::value && sizeof(T) != sizeof(int32_t) && sizeof(T) != sizeof(int64_t), int>::type System::GetHashCode ( const T &  obj)

◆ GetHashCode() [4/6]

template<typename T >
std::enable_if<!std::is_scalar<T>::value && (System::IsSharedPtr<T>::value || System::IsWeakPtr<T>::value), int>::type System::GetHashCode ( const T &  obj)

◆ GetHashCode() [5/6]

template<typename T >
std::enable_if<!std::is_scalar<T>::value && !System::IsSharedPtr<T>::value && !System::IsWeakPtr<T>::value, int>::type System::GetHashCode ( const T &  obj)

◆ GetHashCode() [6/6]

template<>
int System::GetHashCode ( const std::thread::id &  id)
inline

◆ HasFlag()

template<class E >
bool System::HasFlag ( value,
mask 
)

◆ IsInfinity()

template<typename T >
bool System::IsInfinity ( const T &  value)
inline

◆ IsNaN()

template<typename T >
bool System::IsNaN ( const T &  value)
inline

◆ IsNegativeInfinity()

template<typename T >
bool System::IsNegativeInfinity ( const T &  value)
inline

◆ IsPositiveInfinity()

template<typename T >
bool System::IsPositiveInfinity ( const T &  value)
inline

◆ MakeArray() [1/2]

template<typename T >
ArrayPtr<T> System::MakeArray ( std::initializer_list< T >  init)

◆ MakeArray() [2/2]

template<class T , class ... Args>
ArrayPtr<T> System::MakeArray ( Args &&...  args)

◆ MakeObject() [1/2]

template<class T , class ... Args>
std::enable_if<!IsSharedPtr<T>::value, SharedPtr<T> >::type System::MakeObject ( Args &&...  args)

◆ MakeObject() [2/2]

template<class T , class ... Args>
std::enable_if<IsSharedPtr<T>::value, T >::type System::MakeObject ( Args &&...  args)

◆ MakeScopeGuard()

template<typename F >
ScopeGuard<F> System::MakeScopeGuard ( f)

◆ MakeSharedPtr() [1/2]

template<class X >
SharedPtr<X> System::MakeSharedPtr ( X *  p)

◆ MakeSharedPtr() [2/2]

template<class X >
SharedPtr<X> System::MakeSharedPtr ( const X *  p)

◆ MemberwiseClone()

template<typename T >
SharedPtr<Object> System::MemberwiseClone ( T *  ptr)

◆ meta_lock_best_cast() [1/2]

template<typename T >
System::SharedPtr<T> System::meta_lock_best_cast ( const System::WeakPtr< T > &  from)
inline

◆ meta_lock_best_cast() [2/2]

template<typename T >
System::SharedPtr<T>& System::meta_lock_best_cast ( System::SharedPtr< T > &  from)
inline

◆ operator!=() [1/13]

template<class X >
bool System::operator!= ( ArrayPtr< X > const &  x,
std::nullptr_t   
)

◆ operator!=() [2/13]

template<class X >
bool System::operator!= ( std::nullptr_t  ,
ArrayPtr< X > const &  x 
)

◆ operator!=() [3/13]

template<class X >
bool System::operator!= ( WeakPtr< X > const &  x,
std::nullptr_t   
)

◆ operator!=() [4/13]

template<class X >
bool System::operator!= ( std::nullptr_t  ,
WeakPtr< X > const &  x 
)

◆ operator!=() [5/13]

bool System::operator!= ( std::nullptr_t  ,
DateTime  
)

◆ operator!=() [6/13]

template<typename T >
std::enable_if<IsNullable<T>::value, bool>::type System::operator!= ( std::nullptr_t  ,
const T &  other 
)

◆ operator!=() [7/13]

template<typename T1 , typename T2 >
std::enable_if<!IsNullable<T1>::value && IsNullable<T2>::value, bool>::type System::operator!= ( const T1 &  some,
const T2 &  other 
)

◆ operator!=() [8/13]

template<class X , class Y >
bool System::operator!= ( SharedPtr< X >  x,
SharedPtr< Y >  y 
)

◆ operator!=() [9/13]

template<class X >
bool System::operator!= ( SharedPtr< X > const &  x,
std::nullptr_t   
)

◆ operator!=() [10/13]

template<class X >
bool System::operator!= ( std::nullptr_t  ,
SharedPtr< X > const &  x 
)

◆ operator!=() [11/13]

template<class T , typename std::enable_if< IsStringLiteral< T, wchar_t >::value >::type * = nullptr>
bool System::operator!= ( T &  left,
const String right 
)
inline

◆ operator!=() [12/13]

bool System::operator!= ( SharedPtr< Object left,
const String right 
)

◆ operator!=() [13/13]

bool System::operator!= ( std::nullptr_t  ,
const String str 
)

◆ operator*()

template<typename T , typename _ = typename std::enable_if<std::is_arithmetic<T>::value>::type>
Decimal System::operator* ( const T &  x,
const Decimal d 
)

◆ operator+() [1/9]

template<typename T , typename _ = typename std::enable_if<std::is_arithmetic<T>::value>::type>
Decimal System::operator+ ( const T &  x,
const Decimal d 
)

◆ operator+() [2/9]

template<typename T >
std::enable_if<!IsNullable<T>::value && std::is_class<T>::value, Nullable<T> >::type System::operator+ ( std::nullptr_t  ,
const T &   
)

◆ operator+() [3/9]

template<typename T >
std::enable_if<IsNullable<T>::value, T>::type System::operator+ ( std::nullptr_t  ,
const T &   
)

◆ operator+() [4/9]

template<typename T >
std::enable_if<!IsNullable<T>::value && std::is_class<T>::value, Nullable<T> >::type System::operator+ ( const T &  ,
std::nullptr_t   
)

◆ operator+() [5/9]

template<typename T >
std::enable_if<IsNullable<T>::value, T>::type System::operator+ ( const T &  ,
std::nullptr_t   
)

◆ operator+() [6/9]

template<typename T1 , typename T2 , typename = typename std::enable_if<!IsNullable<T1>::value, int>::type, typename = typename std::enable_if<IsNullable<T2>::value, int>::type>
auto System::operator+ ( const T1 &  some,
const T2 &  other 
) -> System::Nullable<decltype(some + other.get_Value())>

◆ operator+() [7/9]

template<typename T >
std::enable_if<IsStringLiteral<T, wchar_t>::value, String>::type System::operator+ ( T &  left,
const String right 
)
inline

◆ operator+() [8/9]

template<typename T >
std::enable_if<IsStringPointer<T, wchar_t>::value, String>::type System::operator+ ( T &  left,
const String right 
)
inline

◆ operator+() [9/9]

String System::operator+ ( const wchar_t  left,
const String right 
)
inline

◆ operator-() [1/3]

int System::operator- ( DayOfWeek  a,
DayOfWeek  b 
)
inline

◆ operator-() [2/3]

template<typename T , typename _ = typename std::enable_if<std::is_arithmetic<T>::value>::type>
Decimal System::operator- ( const T &  x,
const Decimal d 
)

◆ operator-() [3/3]

template<typename T1 , typename T2 , typename = typename std::enable_if<!IsNullable<T1>::value, int>::type, typename = typename std::enable_if<IsNullable<T2>::value, int>::type>
auto System::operator- ( const T1 &  some,
const T2 &  other 
) -> System::Nullable<decltype(some - other.get_Value())>

◆ operator/()

template<typename T , typename _ = typename std::enable_if<std::is_arithmetic<T>::value>::type>
Decimal System::operator/ ( const T &  x,
const Decimal d 
)

◆ operator<()>[1/3]

bool System::operator< ( std::nullptr_t  ,
DateTime  
)

◆ operator<()>[2/3]

template<typename T >
std::enable_if<IsNullable<T>::value, bool>::type System::operator< ( std::nullptr_t  ,
const T &   
)

◆ operator<()>[3/3]

template<typename T1 , typename T2 >
std::enable_if<!IsNullable<T1>::value && IsNullable<T2>::value, bool>::type System::operator< ( const T1 &  some,
const T2 &  other 
)

◆ operator<=()>[1/3]

bool System::operator<= ( std::nullptr_t  ,
DateTime  
)

◆ operator<=()>[2/3]

template<typename T >
std::enable_if<IsNullable<T>::value, bool>::type System::operator<= ( std::nullptr_t  ,
const T &   
)

◆ operator<=()>[3/3]

template<typename T1 , typename T2 >
std::enable_if<!IsNullable<T1>::value && IsNullable<T2>::value, bool>::type System::operator<= ( const T1 &  some,
const T2 &  other 
)

◆ operator==() [1/13]

template<class X >
bool System::operator== ( ArrayPtr< X > const &  x,
std::nullptr_t   
)

◆ operator==() [2/13]

template<class X >
bool System::operator== ( std::nullptr_t  ,
ArrayPtr< X > const &  x 
)

◆ operator==() [3/13]

template<class X >
bool System::operator== ( WeakPtr< X > const &  x,
std::nullptr_t   
)

◆ operator==() [4/13]

template<class X >
bool System::operator== ( std::nullptr_t  ,
WeakPtr< X > const &  x 
)

◆ operator==() [5/13]

template<typename T1 , typename T2 >
std::enable_if<!IsNullable<T1>::value && IsNullable<T2>::value, bool>::type System::operator== ( const T1 &  some,
const T2 &  other 
)

◆ operator==() [6/13]

template<class X , class Y >
bool System::operator== ( SharedPtr< X >  x,
SharedPtr< Y >  y 
)

◆ operator==() [7/13]

template<class X >
bool System::operator== ( SharedPtr< X > const &  x,
std::nullptr_t   
)

◆ operator==() [8/13]

template<class X >
bool System::operator== ( std::nullptr_t  ,
SharedPtr< X > const &  x 
)

◆ operator==() [9/13]

template<class T >
std::enable_if<!std::is_scalar<T>::value && !std::is_pointer<T>::value && !std::is_array<T>::value, bool>::type System::operator== ( T const &  x,
std::nullptr_t   
)

◆ operator==() [10/13]

template<class T >
std::enable_if<!std::is_scalar<T>::value && !std::is_pointer<T>::value && !std::is_array<T>::value, bool>::type System::operator== ( std::nullptr_t  ,
T const &  x 
)

◆ operator==() [11/13]

template<class T , typename std::enable_if< IsStringLiteral< T, wchar_t >::value >::type * = nullptr>
bool System::operator== ( T &  left,
const String right 
)
inline

◆ operator==() [12/13]

bool System::operator== ( SharedPtr< Object left,
const String right 
)

◆ operator==() [13/13]

bool System::operator== ( std::nullptr_t  ,
const String str 
)

◆ operator>() [1/3]

bool System::operator> ( std::nullptr_t  ,
DateTime  
)

◆ operator>() [2/3]

template<typename T >
std::enable_if<IsNullable<T>::value, bool>::type System::operator> ( std::nullptr_t  ,
const T &   
)

◆ operator>() [3/3]

template<typename T1 , typename T2 >
std::enable_if<!IsNullable<T1>::value && IsNullable<T2>::value, bool>::type System::operator> ( const T1 &  some,
const T2 &  other 
)

◆ operator>=() [1/3]

bool System::operator>= ( std::nullptr_t  ,
DateTime  
)

◆ operator>=() [2/3]

template<typename T >
std::enable_if<IsNullable<T>::value, bool>::type System::operator>= ( std::nullptr_t  ,
const T &   
)

◆ operator>=() [3/3]

template<typename T1 , typename T2 >
std::enable_if<!IsNullable<T1>::value && IsNullable<T2>::value, bool>::type System::operator>= ( const T1 &  some,
const T2 &  other 
)

◆ PrintTo() [1/2]

void System::PrintTo ( const Decimal d,
::std::ostream *  os 
)

◆ PrintTo() [2/2]

void System::PrintTo ( const System::String value,
std::ostream *  os 
)

◆ setter_decrement_wrap() [1/2]

template<typename T >
T System::setter_decrement_wrap ( T(*)()  pGetter,
void(*)(T)  pSetter 
)
inline

◆ setter_decrement_wrap() [2/2]

template<typename T , typename Host >
T System::setter_decrement_wrap ( Host *const  host,
T(Host::*)()  pGetter,
void(Host::*)(T)  pSetter 
)
inline

◆ setter_increment_wrap() [1/2]

template<typename T >
T System::setter_increment_wrap ( T(*)()  pGetter,
void(*)(T)  pSetter 
)
inline

◆ setter_increment_wrap() [2/2]

template<typename T , typename Host >
T System::setter_increment_wrap ( Host *const  host,
T(Host::*)()  pGetter,
void(Host::*)(T)  pSetter 
)
inline

◆ setter_post_decrement_wrap() [1/2]

template<typename T >
T System::setter_post_decrement_wrap ( T(*)()  pGetter,
void(*)(T)  pSetter 
)
inline

◆ setter_post_decrement_wrap() [2/2]

template<typename T , typename Host >
T System::setter_post_decrement_wrap ( Host *const  host,
T(Host::*)()  pGetter,
void(Host::*)(T)  pSetter 
)
inline

◆ setter_post_increment_wrap() [1/2]

template<typename T >
T System::setter_post_increment_wrap ( T(*)()  pGetter,
void(*)(T)  pSetter 
)
inline

◆ setter_post_increment_wrap() [2/2]

template<typename T , typename Host >
T System::setter_post_increment_wrap ( Host *const  host,
T(Host::*)()  pGetter,
void(Host::*)(T)  pSetter 
)
inline

◆ setter_wrap() [1/2]

template<typename T , typename T2 >
T System::setter_wrap ( void(*)(T2)  pSetter,
value 
)
inline

◆ setter_wrap() [2/2]

template<typename T , typename T2 , typename Host >
T System::setter_wrap ( Host *const  host,
void(Host::*)(T2)  pSetter,
value 
)
inline

◆ static_pointer_cast() [1/2]

template<class Y , class X >
SharedPtr<Y> System::static_pointer_cast ( const WeakPtr< X > &  x)

◆ static_pointer_cast() [2/2]

template<class Y , class X >
SharedPtr<Y> System::static_pointer_cast ( SharedPtr< X > const &  x)

◆ StaticCastArray()

template<class To , class From >
SharedPtr<Array<To> > System::StaticCastArray ( const SharedPtr< Array< From >> &  from)